posted                       

code:

---

  V2 (0, 10, 0)(.5,1)
   |   \
   |      \
  V1--------V3(10, 0, 0)(1, .5)
  (0,0,0)(.5,.5)

---

code:

---

  V2 (0, 10, 0)(.2,1)
   |   \
   |      \
  V1--------V3(10, 0, 0)(1, .7)
  (0,0,0)(.5,.5)

---

posted                       

code:

---

The relevant input data to your problem are the texture coordinates. 
Tangent and Binormal are vectors locally parallel to the object's surface. 
And in the case of normal mapping they're describing the local orientation of the normal texture.

So you have to calculate the direction (in the model's space) in which the texturing vectors point. 
Say you have a triangle ABC, with texture coordinates HKL. 
This gives us vectors:

D = B-A
E = C-A

F = K-H
G = L-H
Now we want to express D and E in terms of tangent space T, U, i.e.

D = F.s * T + F.t * U
E = G.s * T + G.t * U
This is a system of linear equations with 6 unknowns and 6 equations, it can be written as

| D.x D.y D.z |   | F.s F.t | | T.x T.y T.z |
|             | = |         | |             |
| E.x E.y E.z |   | G.s G.t | | U.x U.y U.z |

Inverting the FG matrix yields

| T.x T.y T.z |           1         |  G.t  -F.t | | D.x D.y D.z |
|             | = ----------------- |            | |             |
| U.x U.y U.z |   F.s G.t - F.t G.s | -G.s   F.s | | E.x E.y E.z |

Together with the vertex normal T and U form a local space basis, called the tangent space, described by the matrix

| T.x U.x N.x |
| T.y U.y N.y |
| T.z U.z N.z |

Transforming from tangent space into object space. To do lighting calculations one needs the inverse of this. 

With a little bit of exercise one finds:

T' = T - (N·T) N
U' = U - (N·U) N - (T'·U) T'

Normalizing the vectors T' and U', calling them tangent and binormal we obtain the matrix transforming from object 
into tangent space, where we do the lighting:

| T'.x T'.y T'.z |
| U'.x U'.y U'.z |
| N.x  N.y  N.z  |

We store T' and U' them together with the vertex normal as a part of the model's geometry (as vertex attributes), 
so that we can use them in the shader for lighting calculations. I repeat: 
You don't determine tangent and binormal in the shader, you precompute them and store them as part of the model's geometry (just like normals).

(The notation between the vertical bars above are all matrices, 
never determinants, which normally use vertical bars instead of brackets in their notation.)

---

posted                       

code:

---

| T.x T.y T.z |           1         |  G.t  -F.t | | D.x D.y D.z |
|             | = ----------------- |            | |             |
| U.x U.y U.z |   F.s G.t - F.t G.s | -G.s   F.s | | E.x E.y E.z |

Together with the vertex normal T and U form a local space basis, called the tangent space, described by the matrix

| T.x U.x N.x |
| T.y U.y N.y |
| T.z U.z N.z |

---

code:

---

on second thought, I think I also need to do the inverstion, but it's not as bad as it first looked


calculateTangent( int numVerts, VERT* verts, TRIPLE *tangents )
{
int numFaces = whatever();
for(int f=0; f<numFaces; f++ ) {
// for each face
TRIPLE N; // we have a face Normal already

for( int v=0; v<numVerts;v++) {
// for each vert of that face
// get two edges

Triple D, E; // XYZ edges
D.set( x1-x0, y1-y0, z1-z0 );
E.set( x2-x0, y2-y0, z2-z0 );

Triple F, G;  // UV edges uv=xy (ignore z)
F.set( u1-u0, v1-v0, 1 );
G.set( u2-u0, v2-v0, 1 );

// now we do this bit
//| T.x T.y T.z |           1         |  G.t  -F.t //| | D.x D.y D.z |
//|             | = ----------------- |            //| |             |
//| U.x U.y U.z |   F.s G.t - F.t G.s | -G.s   F.s //| | E.x E.y E.z |

// that scale factor (where G.xy is G.uv is G.st)

float denominator = (F.x * G.y - F.y * G.x);
if( denominator == 0 ) {
  prepare to fail, try a different edge?
}
float k = 1.0 / denominator ;

// compute T and U from edge data
TRIPLE T, U; // our face tangent and binormal
T.x = k * ( G.y * D.x - F.y * E.x );
T.y = k * ( G.y * D.y - F.y * E.y );
T.z = k * ( G.y * D.z - F.y * E.z );

U.x = k * (-G.x * D.x + F.x * E.x );
U.y = k * (-G.x * D.y + F.x * E.y );
U.z = k * (-G.x * D.z + F.x * E.z );

// in theory T x N should give me U.
// so I could check my work here
if( dist(U, TxN) > epsilon ) error!;

// but it looks like I need the inverses
Triple Ti, Ui;  // these will be final tangent, binormal passed in geometry

//T' = T - (N·T) N
//U' = U - (N·U) N - (T'·U) T'

float NT = dot( N, T);
float NU = dot( N, U);
Ti.x = T.x - NT * N.x;
Ti.y = T.y - NT * N.y;
Ti.z = T.z - NT * N.z;
float TiU = dot( Ti, U );
Ui.x = U.x - (NU * N.x) - ( Tiu * Ti.x);
Ui.y = U.y - (NU * N.y) - ( Tiu * Ti.y);
Ui.z = U.z - (NU * N.z) - ( Tiu * Ti.z);

Ti.normalize();
Ui.normalize();

// do some more error checking to prove
// N, Ti, Ui are unit and mutually orthogonal
// test this with some screwy UV mapping on normal map, 
//like upside down mapping should NOT invert bumps.

// should adjacent faces have equal votes (by
// aggregating normalized face normals) or
// should larger edges have more say?

// perhaps deterministically weighted. anyway...

// aggregate it with faces sharing verts
  verts[ vi ].tangent += Ti;  // maybe reversed
  verts[ vi ].binormal += Ui;
}
}
// second pass normalizes
for( int v=0; v<numVerts;v++) {
// for each vert of that face
  verts[ v ].tangent.normalize();
  verts[ v ].binormal.normalize();
}
}

---