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

Merge pull request #2 from alteous/pr

Browse Source 
Add equivalent C generate example

Former-commit-id: f881f983d4cfebdc20ff46aba0f061c17c26117e
This commit is contained in:
Benjamin Wasty 2017-09-06 09:34:25 +02:00 committed by GitHub
commit b49958ffe1
18 changed files with 131 additions and 2581 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
examples/cube.obj Normal file
View File

@ -0,0 +1,114 @@
v 0.5 -0.5 0.5
v 0.5 -0.5 -0.5
v 0.5 0.5 -0.5
v 0.5 0.5 0.5
v 0.5 0 0
v -0.5 0.5 0.5
v -0.5 0.5 -0.5
v -0.5 -0.5 -0.5
v -0.5 -0.5 0.5
v -0.5 0 0
v 0.5 0.5 0.5
v 0.5 0.5 -0.5
v -0.5 0.5 -0.5
v -0.5 0.5 0.5
v 0 0.5 0
v -0.5 -0.5 0.5
v -0.5 -0.5 -0.5
v 0.5 -0.5 -0.5
v 0.5 -0.5 0.5
v 0 -0.5 0
v -0.5 0.5 0.5
v -0.5 -0.5 0.5
v 0.5 -0.5 0.5
v 0.5 0.5 0.5
v 0 0 0.5
v 0.5 0.5 -0.5
v 0.5 -0.5 -0.5
v -0.5 -0.5 -0.5
v -0.5 0.5 -0.5
v 0 0 -0.5
vn 0.57735026 -0.57735026 0.57735026
vn 0.57735026 -0.57735026 -0.57735026
vn 0.57735026 0.57735026 -0.57735026
vn 0.57735026 0.57735026 0.57735026
vn 1 0 0
vn -0.57735026 0.57735026 0.57735026
vn -0.57735026 0.57735026 -0.57735026
vn -0.57735026 -0.57735026 -0.57735026
vn -0.57735026 -0.57735026 0.57735026
vn -1 0 0
vn 0.57735026 0.57735026 0.57735026
vn 0.57735026 0.57735026 -0.57735026
vn -0.57735026 0.57735026 -0.57735026
vn -0.57735026 0.57735026 0.57735026
vn 0 1 0
vn -0.57735026 -0.57735026 0.57735026
vn -0.57735026 -0.57735026 -0.57735026
vn 0.57735026 -0.57735026 -0.57735026
vn 0.57735026 -0.57735026 0.57735026
vn 0 -1 0
vn -0.57735026 0.57735026 0.57735026
vn -0.57735026 -0.57735026 0.57735026
vn 0.57735026 -0.57735026 0.57735026
vn 0.57735026 0.57735026 0.57735026
vn 0 0 1
vn 0.57735026 0.57735026 -0.57735026
vn 0.57735026 -0.57735026 -0.57735026
vn -0.57735026 -0.57735026 -0.57735026
vn -0.57735026 0.57735026 -0.57735026
vn 0 0 -1
vt 0 0
vt 0 1
vt 1 1
vt 1 0
vt 0.5 0.5
vt 1 0
vt 1 1
vt 0 1
vt 0 0
vt 0.5 0.5
vt 0 0
vt 0 1
vt 0 1
vt 0 0
vt 0 0.5
vt 0 0
vt 0 1
vt 0 1
vt 0 0
vt 0 0.5
vt 0 0
vt 0 1
vt 1 1
vt 1 0
vt 0.5 0.5
vt 1 0
vt 1 1
vt 0 1
vt 0 0
vt 0.5 0.5
f 1/1/1 2/2/2 5/5/5
f 2/2/2 3/3/3 5/5/5
f 3/3/3 4/4/4 5/5/5
f 4/4/4 1/1/1 5/5/5
f 6/6/6 7/7/7 10/10/10
f 7/7/7 8/8/8 10/10/10
f 8/8/8 9/9/9 10/10/10
f 9/9/9 6/6/6 10/10/10
f 11/11/11 12/12/12 15/15/15
f 12/12/12 13/13/13 15/15/15
f 13/13/13 14/14/14 15/15/15
f 14/14/14 11/11/11 15/15/15
f 16/16/16 17/17/17 20/20/20
f 17/17/17 18/18/18 20/20/20
f 18/18/18 19/19/19 20/20/20
f 19/19/19 16/16/16 20/20/20
f 21/21/21 22/22/22 25/25/25
f 22/22/22 23/23/23 25/25/25
f 23/23/23 24/24/24 25/25/25
f 24/24/24 21/21/21 25/25/25
f 26/26/26 27/27/27 30/30/30
f 27/27/27 28/28/28 30/30/30
f 28/28/28 29/29/29 30/30/30
f 29/29/29 26/26/26 30/30/30

66
test-data/generate-test-data.c → examples/generate.c
View File

@ -1,4 +1,3 @@
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
@ -52,18 +51,6 @@ struct input {
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]);
}
@ -86,17 +73,17 @@ int get_num_vertices_of_face(const SMikkTSpaceContext *x, int f) {
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));
memcpy(dst, *src, 3 * sizeof(float));
}
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));
memcpy(dst, *src, 3 * sizeof(float));
}
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));
memcpy(dst, *src, 2 * sizeof(float));
}
void set_tspace_basic(
@ -111,11 +98,14 @@ void set_tspace_basic(
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;
printf("%d: { v: ", i);
print_vec3(in->position);
printf(", vn: ");
print_vec3(in->normal);
printf(", vt: ");
print_vec2(in->tex_coord);
printf(", vx: [%f, %f, %f, %f] }", t[0], t[1], t[2], s);
puts("");
++i;
}
@ -130,22 +120,19 @@ void set_tspace(
int f,
int v
) {
assert(!"unreachable");
set_tspace_basic(x, t, op != 0 ? 1.0f : -1.0f, f, v);
}
int main() {
input.nr_vertices = 406;
input.nr_faces = 682;
output.nr_vertices = 3 * input.nr_faces;
input.nr_vertices = 30;
input.nr_faces = 24;
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");
FILE *fi = fopen("cube.obj", "rb");
assert(fi);
char buffer[1024];
@ -205,7 +192,7 @@ int main() {
.m_getNormal = get_normal,
.m_getTexCoord = get_tex_coord,
.m_setTSpaceBasic = set_tspace_basic,
.m_setTSpace = NULL,
.m_setTSpace = set_tspace,
};
SMikkTSpaceContext context = {
.m_pInterface = &interface,
@ -214,32 +201,11 @@ int main() {
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;
}

2
examples/generate.rs
View File

@ -132,7 +132,6 @@ fn make_cube() -> (Vec<Face>, Vec<Vertex>) {
fn main() {
let (faces, vertices) = make_cube();
let vertex = |face, vert| {
let vs: &[u32; 3] = &faces[face];
&vertices[vs[vert] as usize]
@ -163,5 +162,6 @@ fn main() {
);
assert_eq!(true, ret);
}
println!("{:#?}", new_vertices);
}

BIN
test-data/Avocado.bin
View File

Binary file not shown.

185
test-data/Avocado.gltf
View File

@ -1,185 +0,0 @@
{
"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
View File

@ -1 +0,0 @@
d785dd82e0c6344c7b8ea21b3bf5836fdaf05762

1900
test-data/Avocado.obj
View File

File diff suppressed because it is too large Load Diff

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

@ -1 +0,0 @@
d5f560b94a3a8f04d6f8b6e9513d7dcfad9eaca3

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

@ -1 +0,0 @@
6f3a8b2309c64a078456423015adb8095bb8a159

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

@ -1 +0,0 @@
73f90d59794e139e876b34d48ee1f29671bfdba2

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

@ -1 +0,0 @@
b83cff933c3502a5f176780e8dc7a437e5449f21

BIN
test-data/gen
View File

Binary file not shown.

BIN
test-data/gen2
View File

Binary file not shown.

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

@ -1,45 +0,0 @@
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
View File

Binary file not shown.

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

@ -1,250 +0,0 @@
#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
View File

Binary file not shown.

145
test-data/mikktspace.h
View File

@ -1,145 +0,0 @@
/** \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