Tout d'abord, pour chaque sommet 3D, il existe des vecteurs tangents et bi-tangents infinis. L'image ci-dessous explique pourquoi il y a un nombre infini d'espaces tangents pour chaque sommet, la tangente et la bitangente peuvent avoir n'importe quelle direction dans le plan indiqué.
Donc, afin de calculer correctement l' espace tangent 1 le plus utile , nous voulons que notre espace tangent soit aligné de sorte que l'axe x (la tangente) corresponde à la direction u dans la carte de relief et que l'axe y (bitangent) corresponde à la direction v dans la bump map, nous devrions déjà avoir une normale du sommet qui correspond déjà à la direction Z dans l'espace tangent.
(1) plus utile parce qu'au final, nous voulons que des vecteurs normaux soient échantillonnés à partir de la texture
Cela doit être expliqué avec des images, nous voulons que notre espace tangent soit aligné comme (u, v)
indiqué ci-dessous.
Source de l'image mais pas strictement liée à l'infographie
En infographie, les développeurs utilisent généralement (u,v)
également les coordonnées de texture. Nous supposerons que T est la tangente et B est la bitangente, et P0
est notre sommet cible, qui fait partie du triangle (P0,P1,P2)
.
Rappelez-vous d'abord ce que nous voulions faire, c'est de calculer la tangente et le bitanget qui:
- T aligné avec u et B aligné avec v.
- T et B se trouvent dans le plan avec le sommet normal (le plan montré dans l'image ci-dessus).
Le point est que nous avons déjà supposé que T et B se trouvent dans le même plan et correspondent à U et V maintenant si nous pouvons connaître leurs valeurs, nous pouvons croiser le produit et le troisième vecteur pour construire une matrice de transformation du monde à l'espace tangent.
Étant donné que nous savons que tout vecteur 2D peut être écrit comme une combinaison linéaire de deux vecteurs indépendants 2 et que nous avons déjà les points triangulaires (bords), illustrés dans l'image ci-dessus. Nous pouvons écrire:
E1 = (u1-u0) T + (v1-v0) B
E2 = (u2-u0) T + (v2-v0) B
(2) En fait, c'est ainsi que la matrice de base est dérivée
L'équation ci-dessus peut être écrite sous forme matricielle,
| E1x E1y E1z | | deltaU1 deltaV1 | * | Tx Ty Tz |
| E2x E2y E2z | = | deltaU2 deltaV2 | | Bx By Bz |
En résolvant l'équation des matrices, nous pouvons déterminer les valeurs T et B, nous pouvons construire une matrice de transformation.
Le code source complet en C ++
#include "Vector4D.h"
struct Triangle
{
unsigned short index[3];
};
void CalculateTangentArray(long vertexCount, const Point3D *vertex, const Vector3D *normal,
const Point2D *texcoord, long triangleCount, const Triangle *triangle, Vector4D *tangent)
{
Vector3D *tan1 = new Vector3D[vertexCount * 2];
Vector3D *tan2 = tan1 + vertexCount;
ZeroMemory(tan1, vertexCount * sizeof(Vector3D) * 2);
for (long a = 0; a < triangleCount; a++)
{
long i1 = triangle->index[0];
long i2 = triangle->index[1];
long i3 = triangle->index[2];
const Point3D& v1 = vertex[i1];
const Point3D& v2 = vertex[i2];
const Point3D& v3 = vertex[i3];
const Point2D& w1 = texcoord[i1];
const Point2D& w2 = texcoord[i2];
const Point2D& w3 = texcoord[i3];
float x1 = v2.x - v1.x;
float x2 = v3.x - v1.x;
float y1 = v2.y - v1.y;
float y2 = v3.y - v1.y;
float z1 = v2.z - v1.z;
float z2 = v3.z - v1.z;
float s1 = w2.x - w1.x;
float s2 = w3.x - w1.x;
float t1 = w2.y - w1.y;
float t2 = w3.y - w1.y;
float r = 1.0F / (s1 * t2 - s2 * t1);
Vector3D sdir((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
(t2 * z1 - t1 * z2) * r);
Vector3D tdir((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
(s1 * z2 - s2 * z1) * r);
tan1[i1] += sdir;
tan1[i2] += sdir;
tan1[i3] += sdir;
tan2[i1] += tdir;
tan2[i2] += tdir;
tan2[i3] += tdir;
triangle++;
}
for (long a = 0; a < vertexCount; a++)
{
const Vector3D& n = normal[a];
const Vector3D& t = tan1[a];
// Gram-Schmidt orthogonalize
tangent[a] = (t - n * Dot(n, t)).Normalize();
// Calculate handedness
tangent[a].w = (Dot(Cross(n, t), tan2[a]) < 0.0F) ? -1.0F : 1.0F;
}
delete[] tan1;
}
Le code source complet et la dérivation peuvent être trouvés ici .