Add closures interface

Former-commit-id: 76f4a864fa3b1fbde9d5ac2eab7c5d0639d147ef

Cargo.toml

@@ -1,7 +1,14 @@
 [package]
-name = "mikktspace"
+name = "mikktspace-sys"
 version = "0.1.0"
-authors = ["Benjamin Wasty <benny.wasty@gmail.com>"]
+authors = ["alteous <alteous@outlook.com>"]
+build = "build.rs"
+
+[build-dependencies]
+cmake = "0.1"
 
 [dependencies]
-mikktspace-sys = { path = "./mikktspace-sys" }
+gltf = "0.7"
+
+[[example]]
+name = "generate"

build.rs

@@ -0,0 +1,9 @@
+
+extern crate cmake;
+
+fn main() {
+    let dst = cmake::build("libmikktspace");
+    println!("cargo:rustc-link-search=native={}", dst.display());
+    println!("cargo:rustc-link-lib=static=mikktspace");
+}
+

examples/generate.rs

@@ -0,0 +1,45 @@
+
+extern crate gltf;
+
+use std::io::Write;
+
+fn main() {
+    let path = "test-data/Avocado.gltf";
+    let gltf = gltf::Import::from_path(path).sync().unwrap();
+    let mesh = gltf.meshes().nth(0).unwrap();
+    let primitive = mesh.primitives().nth(0).unwrap();
+    let positions: Vec<[f32; 3]> = primitive.positions().unwrap().collect();
+    let normals: Vec<[f32; 3]> = primitive.normals().unwrap().collect();
+    let mut tex_coords: Vec<[f32; 2]> = vec![];
+    let mut indices: Vec<u16> = vec![];
+    match primitive.tex_coords(0).unwrap() {
+        gltf::mesh::TexCoords::F32(iter) => tex_coords.extend(iter),
+        _ => unreachable!(),
+    }
+    match primitive.indices().unwrap() {
+        gltf::mesh::Indices::U16(iter) => indices.extend(iter),
+        _ => unreachable!(),
+    }
+
+    let file = std::fs::File::create("Avocado.obj").unwrap();
+    let mut writer = std::io::BufWriter::new(file);
+    for position in &positions {
+        writeln!(writer, "v {} {} {}", position[0], position[1], position[2]);
+    }
+    for normal in &normals {
+        writeln!(writer, "vn {} {} {}", normal[0], normal[1], normal[2]);
+    }
+    for tex_coord in &tex_coords {
+        writeln!(writer, "vt {} {}", tex_coord[0], tex_coord[1]);
+    }
+    let mut i = indices.iter();
+    while let (Some(v0), Some(v1), Some(v2)) = (i.next(), i.next(), i.next()) {
+        writeln!(
+            writer,
+            "f {}/{}/{} {}/{}/{} {}/{}/{}",
+            1 + v0, 1 + v0, 1 + v0,
+            1 + v1, 1 + v1, 1 + v1,
+            1 + v2, 1 + v2, 1 + v2,
+        );
+    }
+}

libmikktspace/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 2.8)
+project(mikktspace)
+set(PROJECT_VERSION_MAJOR "1")
+set(PROJECT_VERSION_MINOR "0")
+set(PROJECT_VERSION_PATCH "0")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -std=c11")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_DEBUG} -ggdb -DDEBUG")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_RELEASE} -O2")
+set(SOURCES mikktspace.h mikktspace.c)
+add_library(mikktspace STATIC ${SOURCES})
+install(TARGETS mikktspace ARCHIVE DESTINATION ".")

libmikktspace/mikktspace.h

@@ -0,0 +1,145 @@
+/** \file mikktspace/mikktspace.h
+ *  \ingroup mikktspace
+ */
+/**
+ *  Copyright (C) 2011 by Morten S. Mikkelsen
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty.  In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ *  2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ *  3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef __MIKKTSPACE_H__
+#define __MIKKTSPACE_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Author: Morten S. Mikkelsen
+ * Version: 1.0
+ *
+ * The files mikktspace.h and mikktspace.c are designed to be
+ * stand-alone files and it is important that they are kept this way.
+ * Not having dependencies on structures/classes/libraries specific
+ * to the program, in which they are used, allows them to be copied
+ * and used as is into any tool, program or plugin.
+ * The code is designed to consistently generate the same
+ * tangent spaces, for a given mesh, in any tool in which it is used.
+ * This is done by performing an internal welding step and subsequently an order-independent evaluation
+ * of tangent space for meshes consisting of triangles and quads.
+ * This means faces can be received in any order and the same is true for
+ * the order of vertices of each face. The generated result will not be affected
+ * by such reordering. Additionally, whether degenerate (vertices or texture coordinates)
+ * primitives are present or not will not affect the generated results either.
+ * Once tangent space calculation is done the vertices of degenerate primitives will simply
+ * inherit tangent space from neighboring non degenerate primitives.
+ * The analysis behind this implementation can be found in my master's thesis
+ * which is available for download --> http://image.diku.dk/projects/media/morten.mikkelsen.08.pdf
+ * Note that though the tangent spaces at the vertices are generated in an order-independent way,
+ * by this implementation, the interpolated tangent space is still affected by which diagonal is
+ * chosen to split each quad. A sensible solution is to have your tools pipeline always
+ * split quads by the shortest diagonal. This choice is order-independent and works with mirroring.
+ * If these have the same length then compare the diagonals defined by the texture coordinates.
+ * XNormal which is a tool for baking normal maps allows you to write your own tangent space plugin
+ * and also quad triangulator plugin.
+ */
+
+
+typedef int tbool;
+typedef struct SMikkTSpaceContext SMikkTSpaceContext;
+
+typedef struct {
+	// Returns the number of faces (triangles/quads) on the mesh to be processed.
+	int (*m_getNumFaces)(const SMikkTSpaceContext * pContext);
+
+	// Returns the number of vertices on face number iFace
+	// iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+	int (*m_getNumVerticesOfFace)(const SMikkTSpaceContext * pContext, const int iFace);
+
+	// returns the position/normal/texcoord of the referenced face of vertex number iVert.
+	// iVert is in the range {0,1,2} for triangles and {0,1,2,3} for quads.
+	void (*m_getPosition)(const SMikkTSpaceContext * pContext, float fvPosOut[], const int iFace, const int iVert);
+	void (*m_getNormal)(const SMikkTSpaceContext * pContext, float fvNormOut[], const int iFace, const int iVert);
+	void (*m_getTexCoord)(const SMikkTSpaceContext * pContext, float fvTexcOut[], const int iFace, const int iVert);
+
+	// either (or both) of the two setTSpace callbacks can be set.
+	// The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+
+	// This function is used to return the tangent and fSign to the application.
+	// fvTangent is a unit length vector.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpaceBasic)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int iFace, const int iVert);
+
+	// This function is used to return tangent space results to the application.
+	// fvTangent and fvBiTangent are unit length vectors and fMagS and fMagT are their
+	// true magnitudes which can be used for relief mapping effects.
+	// fvBiTangent is the "real" bitangent and thus may not be perpendicular to fvTangent.
+	// However, both are perpendicular to the vertex normal.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// fSign = bIsOrientationPreserving ? 1.0f : (-1.0f);
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpace)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
+						const tbool bIsOrientationPreserving, const int iFace, const int iVert);
+} SMikkTSpaceInterface;
+
+struct SMikkTSpaceContext
+{
+	SMikkTSpaceInterface * m_pInterface;	// initialized with callback functions
+	void * m_pUserData;						// pointer to client side mesh data etc. (passed as the first parameter with every interface call)
+};
+
+// these are both thread safe!
+tbool genTangSpaceDefault(const SMikkTSpaceContext * pContext);	// Default (recommended) fAngularThreshold is 180 degrees (which means threshold disabled)
+tbool genTangSpace(const SMikkTSpaceContext * pContext, const float fAngularThreshold);
+
+
+// To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
+// normal map sampler must use the exact inverse of the pixel shader transformation.
+// The most efficient transformation we can possibly do in the pixel shader is
+// achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
+// pixel shader (fast transform out)
+// vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+// where vNt is the tangent space normal. The normal map sampler must likewise use the
+// interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
+// sampler does (exact inverse of pixel shader):
+// float3 row0 = cross(vB, vN);
+// float3 row1 = cross(vN, vT);
+// float3 row2 = cross(vT, vB);
+// float fSign = dot(vT, row0)<0 ? -1 : 1;
+// vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
+// where vNout is the sampled normal in some chosen 3D space.
+//
+// Should you choose to reconstruct the bitangent in the pixel shader instead
+// of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
+// Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
+// quads as your renderer then problems will occur since the interpolated tangent spaces will differ
+// eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
+// sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
+// However, this must be used both by the sampler and your tools/rendering pipeline.
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

mikktspace-sys/src/lib.rs

@@ -4,7 +4,6 @@ mod ffi;
 use std::os::raw::*;
 use std::mem;
 
-/// Rust FFI for the MikkTSpace implementation.
 const INTERFACE: ffi::SMikkTSpaceInterface = ffi::SMikkTSpaceInterface {
     m_getNumFaces: faces,
     m_getNumVerticesOfFace: vertices,
@@ -16,26 +15,7 @@ const INTERFACE: ffi::SMikkTSpaceInterface = ffi::SMikkTSpaceInterface {
 };
 
 pub struct Context {
-    faces: Box<ExactSizeIterator<Item = Face>>,
-    positions: Box<ExactSizeIterator<Item = [f32; 3]>>,
-    tex_coords: Box<ExactSizeIterator<Item = [f32; 2]>>,
-    normals: Box<ExactSizeIterator<Item = [f32; 3]>>,
-}
-
-/// Specifies whether a face is a triangle or a quad.
-pub enum Face {
-    Triangle,
-    Quad,
-}
-
-impl Face {
-    /// Returns the number of vertices bound by this face.
-    pub fn vertices(&self) -> i32 {
-        match self {
-            &Face::Triangle { .. } => 3,
-            &Face::Quad { .. } => 4,
-        }
-    }
+    faces: i32,
 }
 
 /// Returns the number of faces (triangles/quads) on the mesh to be processed.
@@ -43,7 +23,7 @@ impl Face {
 extern "C" fn faces(pContext: *const ffi::SMikkTSpaceContext) -> c_int {
     unsafe {
         let m: *const Context = mem::transmute(pContext);
-        (*m).faces.len() as c_int
+        (*m).faces as c_int
     }
 }
 
@@ -56,7 +36,7 @@ extern "C" fn vertices(
 ) -> c_int {
     unsafe {
         let _: *const Context = mem::transmute(pContext);
-        3
+        unimplemented!()
     }
 }
 
@@ -134,19 +114,16 @@ extern "C" fn set_tspace(
 }
 
 impl Context {
-    /// Constructor for a MikkTSpace `Context`.
-    pub fn new<F, P, T, N>(faces: F, positions: P, tex_coords: T, normals: N) -> Self
-    where
-        F: 'static + ExactSizeIterator<Item = Face>,
-        P: 'static + ExactSizeIterator<Item = [f32; 3]>,
-        T: 'static + ExactSizeIterator<Item = [f32; 2]>,
-        N: 'static + ExactSizeIterator<Item = [f32; 3]>,
-    {
+    pub fn new() -> Self {
         Context {
-            faces: Box::new(faces),
-            positions: Box::new(positions),
-            tex_coords: Box::new(tex_coords),
-            normals: Box::new(normals),
+            faces: 3,
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+    }
+}

src/ffi.rs

@@ -0,0 +1,129 @@
+
+#![allow(bad_style)]
+#![allow(dead_code)]
+
+use std::os::raw::*;
+
+pub type tbool = c_int;
+pub const TFALSE: tbool = 0;
+pub const TTRUE: tbool = 1;
+
+#[repr(C)]
+pub struct SMikkTSpaceInterface {
+    /// Returns the number of faces (triangles/quads) on the mesh to be processed.
+    pub m_getNumFaces: extern "C" fn(pContext: *const SMikkTSpaceContext) -> c_int,
+
+    /// Returns the number of vertices on face number iFace
+    /// iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+    pub m_getNumVerticesOfFace: extern "C" fn(
+        pContext: *const SMikkTSpaceContext,
+        iFace: c_int,
+    ) -> c_int,
+
+    /// Returns the position of the referenced face of vertex number
+    /// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+    pub m_getPosition: extern "C" fn(
+        pContext: *const SMikkTSpaceContext,
+        fvPosOut: *mut c_float,
+        iFace: c_int,
+        iVert: c_int,
+    ),
+
+    /// Returns the normal of the referenced face of vertex number
+    /// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+    pub m_getNormal: extern "C" fn(
+        pContext: *const SMikkTSpaceContext,
+        fvNormOut: *mut c_float,
+        iFace: c_int,
+        iVert: c_int,
+    ),
+
+    /// Returns the texcoord of the referenced face of vertex number
+    /// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+    pub m_getTexCoord: extern "C" fn(
+        pContext: *const SMikkTSpaceContext,
+        fvTexcOut: *mut c_float,
+        iFace: c_int,
+        iVert: c_int,
+    ),
+
+    /// either (or both) of the two setTSpace callbacks can be set.
+    /// The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+
+    /// This function is used to return the tangent and fSign to the application.
+    /// fvTangent is a unit length vector.
+    /// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+    /// bitangent = fSign * cross(vN, tangent);
+    /// Note that the results are returned unindexed. It is possible to generate a new index list
+    /// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+    /// DO NOT! use an already existing index list.
+    pub m_setTSpaceBasic: extern "C" fn(
+        pContext: *mut SMikkTSpaceContext,
+        fvTangent: *const c_float,
+        fSign: *const c_float,
+        iFace: c_int,
+        iVert: c_int,
+    ),
+
+    /// This function is used to return tangent space results to the application.
+    /// fvTangent and fvBiTangent are unit length vectors and fMagS and fMagT are their
+    /// true magnitudes which can be used for relief mapping effects.
+    /// fvBiTangent is the "real" bitangent and thus may not be perpendicular to fvTangent.
+    /// However, both are perpendicular to the vertex normal.
+    /// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+    /// fSign = bIsOrientationPreserving ? 1.0f : (-1.0f);
+    /// bitangent = fSign * cross(vN, tangent);
+    /// Note that the results are returned unindexed. It is possible to generate a new index list
+    /// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+    /// DO NOT! use an already existing index list.
+    pub m_setTSpace: extern "C" fn(
+        pContext: *mut SMikkTSpaceContext,
+        fvTangent: *const c_float,
+        fvBiTangent: *const c_float,
+        fMagS: *const c_float,
+        fMagT: *const c_float,
+        bIsOrientationPreserving: tbool,
+        iFace: c_int,
+        iVert: c_int,
+    ),
+}
+
+/// these are both thread safe!
+/// Default (recommended) fAngularThreshold is 180 degrees (which means threshold disabled)
+extern "system" {
+    pub fn genTangSpaceDefault(pContext: *const SMikkTSpaceContext) -> tbool;
+    #[allow(dead_code)]
+    pub fn genTangSpace(pContext: *const SMikkTSpaceContext, fAngularThreshold: c_float) -> tbool;
+}
+
+/// To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
+/// normal map sampler must use the exact inverse of the pixel shader transformation.
+/// The most efficient transformation we can possibly do in the pixel shader is
+/// achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
+/// pixel shader (fast transform out)
+/// vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+/// where vNt is the tangent space normal. The normal map sampler must likewise use the
+/// interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
+/// sampler does (exact inverse of pixel shader):
+/// float3 row0 = cross(vB, vN);
+/// float3 row1 = cross(vN, vT);
+/// float3 row2 = cross(vT, vB);
+/// float fSign = dot(vT, row0)<0 ? -1 : 1;
+/// vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
+/// where vNout is the sampled normal in some chosen 3D space.
+///
+/// Should you choose to reconstruct the bitangent in the pixel shader instead
+/// of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
+/// Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
+/// quads as your renderer then problems will occur since the interpolated tangent spaces will differ
+/// eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
+/// sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
+/// However, this must be used both by the sampler and your tools/rendering pipeline.
+
+#[repr(C)]
+pub struct SMikkTSpaceContext {
+    /// initialized with callback functions
+    pub m_pInterface: *const SMikkTSpaceInterface,
+    /// pointer to client side mesh data etc. (passed as the first parameter with every interface call)
+    pub m_pUserData: *mut c_void,
+}

src/lib.rs

@@ -1,6 +1,168 @@
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
+#![allow(bad_style)]
+
+mod ffi;
+
+use std::os::raw::*;
+use std::mem;
+use std::ptr;
+
+/// Rust FFI for the MikkTSpace implementation.
+const INTERFACE: ffi::SMikkTSpaceInterface = ffi::SMikkTSpaceInterface {
+    m_getNumFaces: faces,
+    m_getNumVerticesOfFace: vertices,
+    m_getPosition: position,
+    m_getNormal: normal,
+    m_getTexCoord: tex_coord,
+    m_setTSpaceBasic: set_tspace_basic,
+    m_setTSpace: set_tspace,
+};
+
+struct Closures<'a> {
+    pub vertices_per_face: &'a Fn() -> usize,
+    
+    /// Returns the number of faces.
+    pub face_count: &'a Fn() -> usize,
+    
+    /// Returns the positions of the indexed face.
+    pub position: &'a Fn(usize, usize) -> &'a [f32; 3],
+
+    /// Returns the normals of the indexed face.
+    pub normal: &'a Fn(usize, usize) -> &'a [f32; 3],
+
+    /// Returns the texture co-ordinates of the indexed face.
+    pub tex_coord: &'a Fn(usize, usize) -> &'a [f32; 2],
+
+    /// Sets the generated tangent for the indexed face.
+    pub set_tangent: &'a mut FnMut(usize, usize, [f32; 4]),
+}
+
+/// Returns the number of faces (triangles/quads) on the mesh to be processed.
+extern "C" fn faces(pContext: *const ffi::SMikkTSpaceContext) -> c_int {
+    unsafe {
+        let x = (*pContext).m_pUserData as *const Closures;
+        ((*x).face_count)() as c_int
     }
 }
+
+/// Returns the number of vertices on face number iFace
+/// iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+extern "C" fn vertices(
+    pContext: *const ffi::SMikkTSpaceContext,
+    _iFace: c_int,
+) -> c_int {
+    unsafe {
+        let x = (*pContext).m_pUserData as *const Closures;
+        ((*x).vertices_per_face)() as c_int
+    }
+}
+
+/// Returns the position of the referenced face of vertex number
+/// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+extern "C" fn position(
+    pContext: *const ffi::SMikkTSpaceContext,
+    fvPosOut: *mut c_float,
+    iFace: c_int,
+    iVert: c_int,
+) {
+    unsafe {
+        let x = (*pContext).m_pUserData as *const Closures;
+        let slice = ((*x).position)(iFace as usize, iVert as usize);
+        let src = slice.as_ptr() as *const c_float;
+        ptr::copy_nonoverlapping::<c_float>(src, fvPosOut, 3);
+    }
+}
+
+/// Returns the normal of the referenced face of vertex number
+/// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+extern "C" fn normal(
+    pContext: *const ffi::SMikkTSpaceContext,
+    fvNormOut: *mut c_float,
+    iFace: c_int,
+    iVert: c_int,
+) {
+    unsafe {
+        let x = (*pContext).m_pUserData as *const Closures;
+        let slice = ((*x).normal)(iFace as usize, iVert as usize);
+        let src = slice.as_ptr() as *const c_float;
+        ptr::copy_nonoverlapping::<c_float>(src, fvNormOut, 3);
+    }
+}
+
+/// Returns the texcoord of the referenced face of vertex number
+/// iVert, in the range {0,1,2} for triangles, and {0,1,2,3} for quads.
+extern "C" fn tex_coord(
+    pContext: *const ffi::SMikkTSpaceContext,
+    fvTexcOut: *mut c_float,
+    iFace: c_int,
+    iVert: c_int,
+) {
+    unsafe {
+        let x = (*pContext).m_pUserData as *const Closures;
+        let slice = ((*x).tex_coord)(iFace as usize, iVert as usize);
+        let src = slice.as_ptr() as *const c_float;
+        ptr::copy_nonoverlapping::<c_float>(src, fvTexcOut, 2);
+    }
+}
+
+/// Returns the tangent and its sign to the application.
+extern "C" fn set_tspace_basic(
+    pContext: *mut ffi::SMikkTSpaceContext,
+    fvTangent: *const c_float,
+    fSign: *const c_float,
+    iFace: c_int,
+    iVert: c_int,
+) {
+    unsafe {
+        let x = (*pContext).m_pUserData as *mut Closures;
+        let mut tangent: [f32; 4] = mem::uninitialized();
+        let dst: *mut c_float = tangent.as_mut_ptr();
+        ptr::copy_nonoverlapping::<c_float>(fvTangent, dst, 3);
+        tangent[3] = *fSign;
+        ((*x).set_tangent)(iFace as usize, iVert as usize, tangent);
+    }
+}
+
+/// Returns tangent space results to the application.
+extern "C" fn set_tspace(
+    _pContext: *mut ffi::SMikkTSpaceContext,
+    _fvTangent: *const c_float,
+    _fvBiTangent: *const c_float,
+    _fMagS: *const c_float,
+    _fMagT: *const c_float,
+    _bIsOrientationPreserving: ffi::tbool,
+    _iFace: c_int,
+    _iVert: c_int,
+) {
+    unimplemented!()
+}
+
+impl<'a> Closures<'a> {
+    pub fn generate(mut self) -> bool {
+        let ctx = ffi::SMikkTSpaceContext {
+            m_pInterface: &INTERFACE,
+            m_pUserData: &mut self as *mut Closures as *mut c_void,
+        };
+        unsafe {
+            ffi::genTangSpaceDefault(&ctx) == ffi::TTRUE
+        }
+    }
+}
+
+pub fn generate<'a>(
+    vertices_per_face: &'a Fn() -> usize,
+    face_count: &'a Fn() -> usize,
+    position: &'a Fn(usize, usize) -> &'a [f32; 3],
+    normal: &'a Fn(usize, usize) -> &'a [f32; 3],
+    tex_coord: &'a Fn(usize, usize) -> &'a [f32; 2],
+    set_tangent: &'a mut FnMut(usize, usize, [f32; 4]),
+) -> bool {
+    let closures = Closures {
+        vertices_per_face,
+        face_count,
+        position,
+        normal,
+        tex_coord,
+        set_tangent,
+    };
+    closures.generate()
+}

test-data/Avocado.gltf

@@ -0,0 +1,185 @@
+{
+  "accessors": [
+    {
+      "bufferView": 0,
+      "componentType": 5126,
+      "count": 406,
+      "type": "VEC2",
+      "max": [
+        0.9824978,
+        -0.00462793233
+      ],
+      "min": [
+        0.00678020436,
+        -0.997018039
+      ]
+    },
+    {
+      "bufferView": 1,
+      "componentType": 5126,
+      "count": 406,
+      "type": "VEC3",
+      "max": [
+        0.9959669,
+        0.974968433,
+        0.9986338
+      ],
+      "min": [
+        -0.995177031,
+        -0.9995665,
+        -0.9988549
+      ]
+    },
+    {
+      "bufferView": 2,
+      "componentType": 5126,
+      "count": 406,
+      "type": "VEC4",
+      "max": [
+        0.929839253,
+        0.998867154,
+        0.9930595,
+        1.0
+      ],
+      "min": [
+        -0.999970555,
+        -0.999693751,
+        -0.995075762,
+        1.0
+      ]
+    },
+    {
+      "bufferView": 3,
+      "componentType": 5126,
+      "count": 406,
+      "type": "VEC3",
+      "max": [
+        0.02128091,
+        0.06284806,
+        0.0138090011
+      ],
+      "min": [
+        -0.02128091,
+        -4.773855E-05,
+        -0.013809
+      ]
+    },
+    {
+      "bufferView": 4,
+      "componentType": 5123,
+      "count": 2046,
+      "type": "SCALAR",
+      "max": [
+        405
+      ],
+      "min": [
+        0
+      ]
+    }
+  ],
+  "asset": {
+    "generator": "glTF Tools for Unity",
+    "version": "2.0"
+  },
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 3248
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 3248,
+      "byteLength": 4872
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 8120,
+      "byteLength": 6496
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 14616,
+      "byteLength": 4872
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 19488,
+      "byteLength": 4092
+    }
+  ],
+  "buffers": [
+    {
+      "uri": "Avocado.bin",
+      "byteLength": 23580
+    }
+  ],
+  "images": [
+    {
+      "uri": "Avocado_baseColor.png"
+    },
+    {
+      "uri": "Avocado_roughnessMetallic.png"
+    },
+    {
+      "uri": "Avocado_normal.png"
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "TEXCOORD_0": 0,
+            "NORMAL": 1,
+            "TANGENT": 2,
+            "POSITION": 3
+          },
+          "indices": 4,
+          "material": 0
+        }
+      ],
+      "name": "Avocado"
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0
+        },
+        "metallicRoughnessTexture": {
+          "index": 1
+        }
+      },
+      "normalTexture": {
+        "index": 2
+      },
+      "name": "2256_Avocado_d"
+    }
+  ],
+  "nodes": [
+    {
+      "mesh": 0,
+      "name": "Avocado"
+    }
+  ],
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "textures": [
+    {
+      "source": 0
+    },
+    {
+      "source": 1
+    },
+    {
+      "source": 2
+    }
+  ]
+}

test-data/Avocado.json.REMOVED.git-id

@@ -0,0 +1 @@
+d785dd82e0c6344c7b8ea21b3bf5836fdaf05762

test-data/AvocadoOut.obj.REMOVED.git-id

@@ -0,0 +1 @@
+d5f560b94a3a8f04d6f8b6e9513d7dcfad9eaca3

test-data/Avocado_baseColor.png.REMOVED.git-id

@@ -0,0 +1 @@
+6f3a8b2309c64a078456423015adb8095bb8a159

test-data/Avocado_normal.png.REMOVED.git-id

@@ -0,0 +1 @@
+73f90d59794e139e876b34d48ee1f29671bfdba2

test-data/Avocado_roughnessMetallic.png.REMOVED.git-id

@@ -0,0 +1 @@
+b83cff933c3502a5f176780e8dc7a437e5449f21

test-data/generate-obj.rs

@@ -0,0 +1,45 @@
+
+extern crate gltf;
+
+use std::io::Write;
+
+fn main() {
+    let path = "test-data/Avocado.gltf";
+    let gltf = gltf::Import::from_path(path).sync().unwrap();
+    let mesh = gltf.meshes().nth(0).unwrap();
+    let primitive = mesh.primitives().nth(0).unwrap();
+    let positions: Vec<[f32; 3]> = primitive.positions().unwrap().collect();
+    let normals: Vec<[f32; 3]> = primitive.normals().unwrap().collect();
+    let mut tex_coords: Vec<[f32; 2]> = vec![];
+    let mut indices: Vec<u16> = vec![];
+    match primitive.tex_coords(0).unwrap() {
+        gltf::mesh::TexCoords::F32(iter) => tex_coords.extend(iter),
+        _ => unreachable!(),
+    }
+    match primitive.indices().unwrap() {
+        gltf::mesh::Indices::U16(iter) => indices.extend(iter),
+        _ => unreachable!(),
+    }
+
+    let file = std::fs::File::create("Avocado.obj").unwrap();
+    let mut writer = std::io::BufWriter::new(file);
+    for position in &positions {
+        writeln!(writer, "v {} {} {}", position[0], position[1], position[2]);
+    }
+    for normal in &normals {
+        writeln!(writer, "vn {} {} {}", normal[0], normal[1], normal[2]);
+    }
+    for tex_coord in &tex_coords {
+        writeln!(writer, "vt {} {}", tex_coord[0], tex_coord[1]);
+    }
+    let mut i = indices.iter();
+    while let (Some(v0), Some(v1), Some(v2)) = (i.next(), i.next(), i.next()) {
+        writeln!(
+            writer,
+            "f {}/{}/{} {}/{}/{} {}/{}/{}",
+            v0, v0, v0,
+            v1, v1, v1,
+            v2, v2, v2,
+        );
+    }
+}

test-data/generate-test-data.c

@@ -0,0 +1,245 @@
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "mikktspace.h"
+
+struct tangent {
+    // Vector.
+    float v[3];
+
+    // Sign.
+    float s;
+};
+
+struct vertex {
+    // Borrows from `input.positions`.
+    float (*position)[3];
+
+    // Borrows from `input.positions`.
+    float (*normal)[3];
+
+    // Borrows from `input.positions`.
+    float (*tex_coord)[2];
+};
+
+struct face {
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct vertex vertices[3];
+};
+
+struct input {
+    // Owned.
+    float (*positions)[3];
+
+    // Owned.
+    float (*normals)[3];
+
+    // Owned.
+    float (*tex_coords)[2];
+
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct face *faces;
+
+    // Number of entries in `positions`, `normals`, and `tex_coords`.
+    size_t nr_vertices;
+
+    // Number of entries in `faces`.
+    size_t nr_faces;
+} input;
+
+struct output {
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct vertex *vertices;
+
+    // Owned.
+    struct tangent *tangents;
+
+    // Number of entries in `vertices` and `tangents`.
+    // Equal to `3 * input.nr_faces`.
+    size_t nr_vertices;
+} output;
+
+void print_vec2(float (*t)[2]) {
+    printf("[%f, %f]", (*t)[0], (*t)[1]);
+}
+
+void print_vec3(float (*t)[3]) {
+    printf("[%f, %f, %f]", (*t)[0], (*t)[1], (*t)[2]);
+}
+
+void print_tangent(const struct tangent *t) {
+    printf("[%f, %f, %f, %f]", t->v[0], t->v[1], t->v[2], t->s);
+}
+
+int get_num_faces(const SMikkTSpaceContext *x) {
+    return input.nr_faces;
+}
+
+int get_num_vertices_of_face(const SMikkTSpaceContext *x, int f) {
+    return 3;
+}
+
+void get_position(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[3] = input.faces[f].vertices[v].position;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void get_normal(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[3] = input.faces[f].vertices[v].normal;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void get_tex_coord(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[2] = input.faces[f].vertices[v].tex_coord;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void set_tspace_basic(
+    const SMikkTSpaceContext *x,
+    const float *t, 
+    float s, 
+    int f, 
+    int v
+) {
+    // The index of the last output (vertex, tangent) pair.
+    static int i = 0;
+
+    struct vertex *in = &input.faces[f].vertices[v];
+
+    output.vertices[i].position = in->position;
+    output.vertices[i].normal = in->normal;
+    output.vertices[i].tex_coord = in->tex_coord;
+    memcpy(output.tangents[i].v, t, 3 * sizeof(float));
+    output.tangents[i].s = s;
+
+    ++i;
+}
+
+void set_tspace(
+    const SMikkTSpaceContext *x, 
+    const float *t,
+    const float *b, 
+    float mag_s, 
+    float mag_t,
+    tbool op,
+    int f, 
+    int v
+) {
+    assert(!"unreachable");
+}
+
+int main() {  
+    input.nr_vertices = 406;
+    input.nr_faces = 682;
+    output.nr_vertices = 3 * input.nr_faces;
+
+    input.positions = calloc(input.nr_vertices, sizeof(*input.positions));
+    input.normals = calloc(input.nr_vertices, sizeof(*input.normals));
+    input.tex_coords = calloc(input.nr_vertices, sizeof(*input.tex_coords));
+    input.faces = calloc(input.nr_faces, sizeof(*input.faces));
+    output.vertices = calloc(output.nr_vertices, sizeof(*output.vertices));
+    output.tangents = calloc(output.nr_vertices, sizeof(*output.tangents));
+
+    FILE *fi = fopen("Avocado.obj", "rb");
+    assert(fi);
+    char buffer[1024];
+
+    for (size_t i = 0; i < input.nr_vertices; ++i) {
+        fgets(buffer, sizeof(buffer), fi);
+        sscanf(
+            buffer, 
+            "v %f %f %f",
+            &input.positions[i][0],
+            &input.positions[i][1],
+            &input.positions[i][2]
+        );
+    }
+
+    for (size_t i = 0; i < input.nr_vertices; ++i) {
+        fgets(buffer, sizeof(buffer), fi);
+        sscanf(
+            buffer, 
+            "vn %f %f %f",
+            &input.normals[i][0], 
+            &input.normals[i][1],
+            &input.normals[i][2]
+        );
+    }
+    
+    for (size_t i = 0; i < input.nr_vertices; ++i) {
+        fgets(buffer, sizeof(buffer), fi);
+        sscanf(
+            buffer, 
+            "vt %f %f",
+            &input.tex_coords[i][0], 
+            &input.tex_coords[i][1]
+        );
+    }
+
+    for (size_t i = 0; i < input.nr_faces; ++i) {
+        fgets(buffer, sizeof(buffer), fi);
+        int v[3];
+        sscanf(
+            buffer, 
+            "f %d/%d/%d %d/%d/%d %d/%d/%d",
+            &v[0], &v[0], &v[0],
+            &v[1], &v[1], &v[1],
+            &v[2], &v[2], &v[2]
+        );
+        for (size_t j = 0; j < 3; ++j) {
+            input.faces[i].vertices[j].position = &input.positions[v[j] - 1];
+            input.faces[i].vertices[j].normal = &input.normals[v[j] - 1];
+            input.faces[i].vertices[j].tex_coord = &input.tex_coords[v[j] - 1];
+        }
+    }
+
+    SMikkTSpaceInterface interface = {
+        .m_getNumFaces = get_num_faces,
+        .m_getNumVerticesOfFace = get_num_vertices_of_face,
+        .m_getPosition = get_position,
+        .m_getNormal = get_normal,
+        .m_getTexCoord = get_tex_coord,
+        .m_setTSpaceBasic = set_tspace_basic,
+        .m_setTSpace = NULL,
+    };
+    SMikkTSpaceContext context = {
+        .m_pInterface = &interface,
+        .m_pUserData = NULL,
+    };
+
+    genTangSpaceDefault(&context);
+
+    printf("{\n  \"vlist\": [\n");
+    for (size_t i = 0; i < output.nr_vertices; ++i) {
+	printf("    {\"v\": ");
+	print_vec3(output.vertices[i].position);
+	printf(", \"vn\": ");
+	print_vec3(output.vertices[i].normal);
+	printf(", \"vt\": ");
+	print_vec2(output.vertices[i].tex_coord);
+	printf(", \"vx\": ");
+	print_tangent(&output.tangents[i]);
+	if (i == output.nr_vertices - 1) {
+	    printf("}\n");
+	} else {
+	    printf("},\n");
+	}
+    }
+    printf("  ]\n}");	   
+    
+    fclose(fi);
+    free(input.positions);
+    free(input.normals);
+    free(input.tex_coords);
+    free(input.faces);
+    free(output.vertices);
+    free(output.tangents);
+
+    return 0;
+}
+

test-data/generate-test-obj.c

@@ -0,0 +1,250 @@
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "mikktspace.h"
+
+struct tangent {
+    // Vector.
+    float v[3];
+
+    // Sign.
+    float s;
+};
+
+struct vertex {
+    // Borrows from `input.positions`.
+    float (*position)[3];
+
+    // Borrows from `input.positions`.
+    float (*normal)[3];
+
+    // Borrows from `input.positions`.
+    float (*tex_coord)[2];
+};
+
+struct face {
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct vertex vertices[3];
+};
+
+struct input {
+    // Owned.
+    float (*positions)[3];
+
+    // Owned.
+    float (*normals)[3];
+
+    // Owned.
+    float (*tex_coords)[2];
+
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct face *faces;
+
+    // Number of entries in `positions`, `normals`, and `tex_coords`.
+    size_t nr_vertices;
+
+    // Number of entries in `faces`.
+    size_t nr_faces;
+} input;
+
+struct output {
+    // Borrows from `positions`, `normals`, and `tex_coords`.
+    struct vertex *vertices;
+
+    // Owned.
+    struct tangent *tangents;
+
+    // Number of entries in `vertices` and `tangents`.
+    // Equal to `3 * input.nr_faces`.
+    size_t nr_vertices;
+} output;
+
+void print_vec2(float (*t)[2]) {
+    printf("%f %f", (*t)[0], (*t)[1]);
+}
+
+void print_vec3(float (*t)[3]) {
+    printf("%f %f %f", (*t)[0], (*t)[1], (*t)[2]);
+}
+
+void print_tangent(const struct tangent *t) {
+    printf("%f %f %f %f", t->v[0], t->v[1], t->v[2], t->s);
+}
+
+int get_num_faces(const SMikkTSpaceContext *x) {
+    return input.nr_faces;
+}
+
+int get_num_vertices_of_face(const SMikkTSpaceContext *x, int f) {
+    return 3;
+}
+
+void get_position(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[3] = input.faces[f].vertices[v].position;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void get_normal(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[3] = input.faces[f].vertices[v].normal;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void get_tex_coord(const SMikkTSpaceContext *x, float *dst, int f, int v) {
+    float (*src)[2] = input.faces[f].vertices[v].tex_coord;
+    memcpy(dst, src, sizeof(*src));
+}
+
+void set_tspace_basic(
+    const SMikkTSpaceContext *x,
+    const float *t, 
+    float s, 
+    int f, 
+    int v
+) {
+    // The index of the last output (vertex, tangent) pair.
+    static int i = 0;
+
+    struct vertex *in = &input.faces[f].vertices[v];
+
+    output.vertices[i].position = in->position;
+    output.vertices[i].normal = in->normal;
+    output.vertices[i].tex_coord = in->tex_coord;
+    memcpy(output.tangents[i].v, t, 3 * sizeof(float));
+    output.tangents[i].s = s;
+
+    ++i;
+}
+
+void set_tspace(
+    const SMikkTSpaceContext *x, 
+    const float *t,
+    const float *b, 
+    float mag_s, 
+    float mag_t,
+    tbool op,
+    int f, 
+    int v
+) {
+    assert(!"unreachable");
+}
+
+int main() {  
+    input.nr_vertices = 406;
+    input.nr_faces = 682;
+    output.nr_vertices = 3 * input.nr_faces;
+
+    input.positions = calloc(input.nr_vertices, sizeof(*input.positions));
+    input.normals = calloc(input.nr_vertices, sizeof(*input.normals));
+    input.tex_coords = calloc(input.nr_vertices, sizeof(*input.tex_coords));
+    input.faces = calloc(input.nr_faces, sizeof(*input.faces));
+    output.vertices = calloc(output.nr_vertices, sizeof(*output.vertices));
+    output.tangents = calloc(output.nr_vertices, sizeof(*output.tangents));
+
+    {
+	FILE *fi = fopen("Avocado.obj", "rb");
+	assert(fi);
+	char buffer[1024];
+
+	for (size_t i = 0; i < input.nr_vertices; ++i) {
+	    fgets(buffer, sizeof(buffer), fi);
+	    sscanf(
+		   buffer, 
+		   "v %f %f %f",
+		   &input.positions[i][0],
+		   &input.positions[i][1],
+		   &input.positions[i][2]
+		   );
+	}
+
+	for (size_t i = 0; i < input.nr_vertices; ++i) {
+	    fgets(buffer, sizeof(buffer), fi);
+	    sscanf(
+		   buffer, 
+		   "vn %f %f %f",
+		   &input.normals[i][0], 
+		   &input.normals[i][1],
+		   &input.normals[i][2]
+		   );
+	}
+    
+	for (size_t i = 0; i < input.nr_vertices; ++i) {
+	    fgets(buffer, sizeof(buffer), fi);
+	    sscanf(
+		   buffer, 
+		   "vt %f %f",
+		   &input.tex_coords[i][0], 
+		   &input.tex_coords[i][1]
+		   );
+	}
+
+	for (size_t i = 0; i < input.nr_faces; ++i) {
+	    fgets(buffer, sizeof(buffer), fi);
+	    int v[3];
+	    sscanf(
+		   buffer, 
+		   "f %d/%d/%d %d/%d/%d %d/%d/%d",
+		   &v[0], &v[0], &v[0],
+		   &v[1], &v[1], &v[1],
+		   &v[2], &v[2], &v[2]
+		   );
+	    for (size_t j = 0; j < 3; ++j) {
+		input.faces[i].vertices[j].position = &input.positions[v[j] - 1];
+		input.faces[i].vertices[j].normal = &input.normals[v[j] - 1];
+		input.faces[i].vertices[j].tex_coord = &input.tex_coords[v[j] - 1];
+	    }
+	}
+
+	fclose(fi);
+    }
+    
+    SMikkTSpaceInterface interface = {
+	.m_getNumFaces = get_num_faces,
+	.m_getNumVerticesOfFace = get_num_vertices_of_face,
+	.m_getPosition = get_position,
+	.m_getNormal = get_normal,
+	.m_getTexCoord = get_tex_coord,
+        .m_setTSpaceBasic = set_tspace_basic,
+        .m_setTSpace = NULL,
+    };
+    SMikkTSpaceContext context = {
+        .m_pInterface = &interface,
+        .m_pUserData = NULL,
+    };
+
+    genTangSpaceDefault(&context);
+
+    for (size_t i = 0; i < output.nr_vertices; ++i) {
+	printf("v ");
+	print_vec3(output.vertices[i].position);
+	printf("\n");
+    }
+    
+    for (size_t i = 0; i < output.nr_vertices; ++i) {
+	printf("vn ");
+	print_vec3(output.vertices[i].normal);
+	printf("\n");
+    }
+
+    int k = 1;
+    for (size_t i = 0; i < output.nr_vertices / 3; ++i) {
+	int v0 = k++;
+	int v1 = k++;
+	int v2 = k++;
+	printf("f %d//%d %d//%d %d//%d\n", v0, v0, v1, v1, v2, v2);
+    }
+
+    free(input.positions);
+    free(input.normals);
+    free(input.tex_coords);
+    free(input.faces);
+    free(output.vertices);
+    free(output.tangents);
+
+    return 0;
+}
+

test-data/mikktspace.h

@@ -0,0 +1,145 @@
+/** \file mikktspace/mikktspace.h
+ *  \ingroup mikktspace
+ */
+/**
+ *  Copyright (C) 2011 by Morten S. Mikkelsen
+ *
+ *  This software is provided 'as-is', without any express or implied
+ *  warranty.  In no event will the authors be held liable for any damages
+ *  arising from the use of this software.
+ *
+ *  Permission is granted to anyone to use this software for any purpose,
+ *  including commercial applications, and to alter it and redistribute it
+ *  freely, subject to the following restrictions:
+ *
+ *  1. The origin of this software must not be misrepresented; you must not
+ *     claim that you wrote the original software. If you use this software
+ *     in a product, an acknowledgment in the product documentation would be
+ *     appreciated but is not required.
+ *  2. Altered source versions must be plainly marked as such, and must not be
+ *     misrepresented as being the original software.
+ *  3. This notice may not be removed or altered from any source distribution.
+ */
+
+#ifndef __MIKKTSPACE_H__
+#define __MIKKTSPACE_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Author: Morten S. Mikkelsen
+ * Version: 1.0
+ *
+ * The files mikktspace.h and mikktspace.c are designed to be
+ * stand-alone files and it is important that they are kept this way.
+ * Not having dependencies on structures/classes/libraries specific
+ * to the program, in which they are used, allows them to be copied
+ * and used as is into any tool, program or plugin.
+ * The code is designed to consistently generate the same
+ * tangent spaces, for a given mesh, in any tool in which it is used.
+ * This is done by performing an internal welding step and subsequently an order-independent evaluation
+ * of tangent space for meshes consisting of triangles and quads.
+ * This means faces can be received in any order and the same is true for
+ * the order of vertices of each face. The generated result will not be affected
+ * by such reordering. Additionally, whether degenerate (vertices or texture coordinates)
+ * primitives are present or not will not affect the generated results either.
+ * Once tangent space calculation is done the vertices of degenerate primitives will simply
+ * inherit tangent space from neighboring non degenerate primitives.
+ * The analysis behind this implementation can be found in my master's thesis
+ * which is available for download --> http://image.diku.dk/projects/media/morten.mikkelsen.08.pdf
+ * Note that though the tangent spaces at the vertices are generated in an order-independent way,
+ * by this implementation, the interpolated tangent space is still affected by which diagonal is
+ * chosen to split each quad. A sensible solution is to have your tools pipeline always
+ * split quads by the shortest diagonal. This choice is order-independent and works with mirroring.
+ * If these have the same length then compare the diagonals defined by the texture coordinates.
+ * XNormal which is a tool for baking normal maps allows you to write your own tangent space plugin
+ * and also quad triangulator plugin.
+ */
+
+
+typedef int tbool;
+typedef struct SMikkTSpaceContext SMikkTSpaceContext;
+
+typedef struct {
+	// Returns the number of faces (triangles/quads) on the mesh to be processed.
+	int (*m_getNumFaces)(const SMikkTSpaceContext * pContext);
+
+	// Returns the number of vertices on face number iFace
+	// iFace is a number in the range {0, 1, ..., getNumFaces()-1}
+	int (*m_getNumVerticesOfFace)(const SMikkTSpaceContext * pContext, const int iFace);
+
+	// returns the position/normal/texcoord of the referenced face of vertex number iVert.
+	// iVert is in the range {0,1,2} for triangles and {0,1,2,3} for quads.
+	void (*m_getPosition)(const SMikkTSpaceContext * pContext, float fvPosOut[], const int iFace, const int iVert);
+	void (*m_getNormal)(const SMikkTSpaceContext * pContext, float fvNormOut[], const int iFace, const int iVert);
+	void (*m_getTexCoord)(const SMikkTSpaceContext * pContext, float fvTexcOut[], const int iFace, const int iVert);
+
+	// either (or both) of the two setTSpace callbacks can be set.
+	// The call-back m_setTSpaceBasic() is sufficient for basic normal mapping.
+
+	// This function is used to return the tangent and fSign to the application.
+	// fvTangent is a unit length vector.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpaceBasic)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fSign, const int iFace, const int iVert);
+
+	// This function is used to return tangent space results to the application.
+	// fvTangent and fvBiTangent are unit length vectors and fMagS and fMagT are their
+	// true magnitudes which can be used for relief mapping effects.
+	// fvBiTangent is the "real" bitangent and thus may not be perpendicular to fvTangent.
+	// However, both are perpendicular to the vertex normal.
+	// For normal maps it is sufficient to use the following simplified version of the bitangent which is generated at pixel/vertex level.
+	// fSign = bIsOrientationPreserving ? 1.0f : (-1.0f);
+	// bitangent = fSign * cross(vN, tangent);
+	// Note that the results are returned unindexed. It is possible to generate a new index list
+	// But averaging/overwriting tangent spaces by using an already existing index list WILL produce INCRORRECT results.
+	// DO NOT! use an already existing index list.
+	void (*m_setTSpace)(const SMikkTSpaceContext * pContext, const float fvTangent[], const float fvBiTangent[], const float fMagS, const float fMagT,
+						const tbool bIsOrientationPreserving, const int iFace, const int iVert);
+} SMikkTSpaceInterface;
+
+struct SMikkTSpaceContext
+{
+	SMikkTSpaceInterface * m_pInterface;	// initialized with callback functions
+	void * m_pUserData;						// pointer to client side mesh data etc. (passed as the first parameter with every interface call)
+};
+
+// these are both thread safe!
+tbool genTangSpaceDefault(const SMikkTSpaceContext * pContext);	// Default (recommended) fAngularThreshold is 180 degrees (which means threshold disabled)
+tbool genTangSpace(const SMikkTSpaceContext * pContext, const float fAngularThreshold);
+
+
+// To avoid visual errors (distortions/unwanted hard edges in lighting), when using sampled normal maps, the
+// normal map sampler must use the exact inverse of the pixel shader transformation.
+// The most efficient transformation we can possibly do in the pixel shader is
+// achieved by using, directly, the "unnormalized" interpolated tangent, bitangent and vertex normal: vT, vB and vN.
+// pixel shader (fast transform out)
+// vNout = normalize( vNt.x * vT + vNt.y * vB + vNt.z * vN );
+// where vNt is the tangent space normal. The normal map sampler must likewise use the
+// interpolated and "unnormalized" tangent, bitangent and vertex normal to be compliant with the pixel shader.
+// sampler does (exact inverse of pixel shader):
+// float3 row0 = cross(vB, vN);
+// float3 row1 = cross(vN, vT);
+// float3 row2 = cross(vT, vB);
+// float fSign = dot(vT, row0)<0 ? -1 : 1;
+// vNt = normalize( fSign * float3(dot(vNout,row0), dot(vNout,row1), dot(vNout,row2)) );
+// where vNout is the sampled normal in some chosen 3D space.
+//
+// Should you choose to reconstruct the bitangent in the pixel shader instead
+// of the vertex shader, as explained earlier, then be sure to do this in the normal map sampler also.
+// Finally, beware of quad triangulations. If the normal map sampler doesn't use the same triangulation of
+// quads as your renderer then problems will occur since the interpolated tangent spaces will differ
+// eventhough the vertex level tangent spaces match. This can be solved either by triangulating before
+// sampling/exporting or by using the order-independent choice of diagonal for splitting quads suggested earlier.
+// However, this must be used both by the sampler and your tools/rendering pipeline.
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif