forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #1 from alteous/pr

Browse Source 
Add bindings to C reference implementation

Former-commit-id: 8964a4bb729250aedd7f53bc4d6af9adff3c9ef1
This commit is contained in:
Benjamin Wasty 2017-08-30 23:41:41 +02:00 committed by GitHub
commit a94c513a0c
25 changed files with 5307 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -1,3 +1,5 @@
/target/
/mikktspace-sys/target/
/mikktspace-sys/libmikktspace/libmikktspace.a
**/*.rs.bk
Cargo.lock

8
Cargo.toml
View File

@ -2,5 +2,13 @@
name = "mikktspace"
version = "0.1.0"
authors = ["Benjamin Wasty <benny.wasty@gmail.com>"]
build = "build.rs"
[build-dependencies]
cmake = "0.1"
[dependencies]
cgmath = "0.15"
[[example]]
name = "generate"

9
build.rs Normal file
View File

@ -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");
}

167
examples/generate.rs Normal file
View File

@ -0,0 +1,167 @@
extern crate cgmath;
extern crate mikktspace;
use cgmath::prelude::*;
pub type Face = [u32; 3];
pub type Vec2 = [f32; 2];
pub type Vec3 = [f32; 3];
pub type Vec4 = [f32; 4];
#[derive(Debug)]
struct Vertex {
position: Vec3,
normal: Vec3,
tex_coord: Vec2,
}
#[derive(Debug)]
struct NewVertex {
position: Vec3,
normal: Vec3,
tex_coord: Vec2,
tangent: Vec4,
}
fn make_cube() -> (Vec<Face>, Vec<Vertex>) {
struct ControlPoint {
uv: Vec2,
dir: Vec3,
}
let mut faces = Vec::new();
let mut ctl_pts = Vec::new();
let mut vertices = Vec::new();
// +x plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 1.0], dir: [1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 0.0], dir: [1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.5, 0.5], dir: [1.0, 0.0, 0.0] });
}
// -x plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [1.0, 0.0], dir: [-1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 1.0], dir: [-1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [-1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [-1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.5, 0.5], dir: [-1.0, 0.0, 0.0] });
}
// +y plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [-1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [-1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.5], dir: [0.0, 1.0, 0.0] });
}
// -y plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [-1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [-1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.5], dir: [0.0, -1.0, 0.0] });
}
// +z plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [-1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [-1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 1.0], dir: [1.0, -1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 0.0], dir: [1.0, 1.0, 1.0] });
ctl_pts.push(ControlPoint { uv: [0.5, 0.5], dir: [0.0, 0.0, 1.0] });
}
// -z plane
{
let base = ctl_pts.len() as u32;
faces.push([base, base + 1, base + 4]);
faces.push([base + 1, base + 2, base + 4]);
faces.push([base + 2, base + 3, base + 4]);
faces.push([base + 3, base, base + 4]);
ctl_pts.push(ControlPoint { uv: [1.0, 0.0], dir: [1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [1.0, 1.0], dir: [1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 1.0], dir: [-1.0, -1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.0, 0.0], dir: [-1.0, 1.0, -1.0] });
ctl_pts.push(ControlPoint { uv: [0.5, 0.5], dir: [0.0, 0.0, -1.0] });
}
for pt in ctl_pts {
let p: cgmath::Vector3<f32> = pt.dir.into();
let n: cgmath::Vector3<f32> = p.normalize();
let t: cgmath::Vector2<f32> = pt.uv.into();
vertices.push(Vertex {
position: (p / 2.0).into(),
normal: n.into(),
tex_coord: t.into(),
});
}
(faces, vertices)
}
fn main() {
let (faces, vertices) = make_cube();
let vertex = |face, vert| {
let vs: &[u32; 3] = &faces[face];
&vertices[vs[vert] as usize]
};
let vertices_per_face = || 3;
let face_count = || faces.len();
let position = |face, vert| &vertex(face, vert).position;
let normal = |face, vert| &vertex(face, vert).normal;
let tex_coord = |face, vert| &vertex(face, vert).tex_coord;
let mut new_vertices = Vec::new();
{
let mut set_tangent = |face, vert, tangent| {
new_vertices.push(NewVertex {
position: *position(face, vert),
normal: *normal(face, vert),
tex_coord: *tex_coord(face, vert),
tangent: tangent,
});
};
let ret = mikktspace::generate(
&vertices_per_face,
&face_count,
&position,
&normal,
&tex_coord,
&mut set_tangent,
);
assert_eq!(true, ret);
}
println!("{:#?}", new_vertices);
}

11
libmikktspace/CMakeLists.txt Normal file
View File

@ -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 ".")

1890
libmikktspace/mikktspace.c Normal file
View File

File diff suppressed because it is too large Load Diff

145
libmikktspace/mikktspace.h Normal file
View File

@ -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

129
src/ffi.rs Normal file
View File

@ -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: 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: c_float,
fMagT: 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,
}

175
src/lib.rs
View File

@ -1,6 +1,173 @@
#[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,
};
/// Rust front-end API for tangent generation.
struct Closures<'a> {
/// Returns the number of vertices per face.
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: 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: c_float,
_fMagT: c_float,
bIsOrientationPreserving: ffi::tbool,
iFace: c_int,
iVert: c_int,
) {
let fSign = if bIsOrientationPreserving != 0 { 1.0 } else { -1.0 };
set_tspace_basic(pContext, fvTangent, fSign, iFace, iVert);
}
impl<'a> Closures<'a> {
/// Generates tangents.
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
}
}
}
/// Generates tangents.
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()
}

BIN
test-data/Avocado.bin Normal file
View File

Binary file not shown.

185
test-data/Avocado.gltf Normal file
View File

@ -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
}
]
}

1
test-data/Avocado.json.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
d785dd82e0c6344c7b8ea21b3bf5836fdaf05762

1900
test-data/Avocado.obj Normal file
View File

File diff suppressed because it is too large Load Diff

1
test-data/AvocadoOut.obj.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
d5f560b94a3a8f04d6f8b6e9513d7dcfad9eaca3

1
test-data/Avocado_baseColor.png.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
6f3a8b2309c64a078456423015adb8095bb8a159

1
test-data/Avocado_normal.png.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
73f90d59794e139e876b34d48ee1f29671bfdba2

1
test-data/Avocado_roughnessMetallic.png.REMOVED.git-id Normal file
View File

@ -0,0 +1 @@
b83cff933c3502a5f176780e8dc7a437e5449f21

BIN
test-data/gen Executable file
View File

Binary file not shown.

BIN
test-data/gen2 Executable file
View File

Binary file not shown.

45
test-data/generate-obj.rs Normal file
View File

@ -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,
);
}
}

BIN
test-data/generate-test-data Executable file
View File

Binary file not shown.

245
test-data/generate-test-data.c Normal file
View File

@ -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;
}

250
test-data/generate-test-obj.c Normal file
View File

@ -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;
}

BIN
test-data/libmikktspace.a Normal file
View File

Binary file not shown.

145
test-data/mikktspace.h Normal file
View File

@ -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