Couple of questions regarding CalcTangentsProcess.cpp

[prunoid]

Hi,
I'm running into problems when generating TBNs using the code from CalcTangentsProcess.cpp
I'm assuming it's my code that is at fault but also want to rule out issues with the Assimp tangent calculation code too.

1. I understand that the tangent and bitangent for a vertex are usually derived by multiplying the face vertex deltas for two connected edges, by the inverse of the UV delta matrix. The UV delta inverse being (1 / determinant) * adjugate. So why doesn't the 1/determinant appear in CalcTangentsProcess code ?

From the code, the tangent.x, is calculated as:
tangent.x = (w.x * sy - v.x * ty) * dirCorrection;
Is it because the UV delta matrix is taken to be orthonormal and so the inverse can be simplified to the transpose?

2. Is there a reason why the localBitangent is calculated as:
   aiVector3D localBitangent = bitangent - meshNorm[p] * (bitangent * meshNorm[p]) - localTangent * (bitangent * localTangent);
   Instead of using the vector a.k.a. cross product?
   So:
   localBitangent = meshNorm[p] ^ localTangent;

Thanks.

[kimkulling]

Hi,
I will try to help you here:

1. The tangents and bitangets are calculated with the precondition that the UV-delta-matrix is taken to be orthogonal, that is correct. This is a simplification to make the post-process not too complex.
2. Honestly speaking: I don't know why this calculation was used instead of just using the cross-product. The code was not written by me. Maybe this would be a useful improvement of the post-processing step.

Kim

[prunoid]

Thanks Kim,
both replies make sense.

For info, the normal mapping problem I'm encountering is as follows:
I have a custom Blender terrain exporter, which outputs vertex array ready faces, verts, norms and UVs. When I run these through the Assimp CalcTangentsProcess, its produces the output you see in the images.
The issue occurs based on the directional light to surface angle and also the view position but I can't figure out why this is happening.
Terrain lighting is simple diffuse max(dot(n, l), 0.0) based. With both vectors in tangent space.
There is no specular, view dependent element to the lighting.

At one point, I thought the issue might be use of a normal map downloaded from a web source and so might be DirectX axis aligned. (I'm using OpenGL/GLSL on Linux.)
However, inverting the normal green component (g = 1 - g) didn't help.

So if anyone has seen a similar effect and has any suggestions - please let me know.

Cheers Will.

Some images.....

Directional light behind viewer and at around 45 degrees above horizon (Note terrain rocks appear concave "indented"):

Directional light in same place but player moved to the right and rotated to the left to look at same area of terrain (Note terrain rocks appear convex - which is correct) :

Finally same viewer position, but in FPS mode, with sun allowed to move to opposite side of the sky and almost a setting position. (Note Same rocks have good normal mapped effect):

[prunoid]

UPDATE - After:

• Rewriting my Blender terrain exporter to index vertices/faces in a similar way to .OBJ;
• Rewriting my rendering engine importer to convert from a .OBJ binary format to OpenGL vertex array
• And finally writing my own version of tangent calculation....

The problem was simply that I added tangent VBO creation, AFTER I had unbound my vertex array. So all the refactoring in the world, had no affect whatsoever, as the populated tangent buffer was never being fed into my vertex shader.

How on Earth did I miss that :-)

One good thing to come out of all this, is a full understanding of tangent calculation and a simpler and more efficient tangent calculation routine.
The Assimp calc tangents doesn't use the face index data, which is present in many model file formats. Instead the post-process step finds all shared vertices again, based on similar vertex positions, normals and UVs.
I understand why Assimp does this, as the file parsers all generate the same simplified data structures for use in the post-processing step. But for my purposes, iterating over the original face vertices and summing tangents based on vertex indices is much more efficient and 100% accurate.
Here's my rough code with credit due to the article at: [http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-13-normal-mapping/] for some code snippets:

void TerrainCache::calcTangentsAndBitangents (
		uint numFaces, uint* faceIndices,
		uint numVerts, float* vertices,
		float* UVs,
		float* normals,
		aiVector3D* vlhsTangents, aiVector3D* vlhsBitangents) {

    aiVector3D* meshPs = reinterpret_cast<aiVector3D*> (vertices);
    aiVector3D* meshNs = reinterpret_cast<aiVector3D*> (normals);
    Tvec* meshUVs = reinterpret_cast<Tvec*> (UVs);

    // Calculate the tangent and bitangent for every face
    for (uint fIdx = 0; fIdx < numFaces; ++fIdx) {

        uint* face = &(faceIndices[fIdx * 3]);
        uint pIdx0 = face[0], pIdx1 = face[1], pIdx2 = face[2];

        // Get the face vertex positions
        aiVector3D& v0 = meshPs[pIdx0];
        aiVector3D& v1 = meshPs[pIdx1];
        aiVector3D& v2 = meshPs[pIdx2];

        // Get the face vertex UVs
        Tvec& uv0 = meshUVs[pIdx0];
        Tvec& uv1 = meshUVs[pIdx1];
        Tvec& uv2 = meshUVs[pIdx2];

	// Edges of the triangle (position delta)
        aiVector3D deltaPos1 = v1 - v0;
        aiVector3D deltaPos2 = v2 - v0;

	// UV delta
        Tvec deltaUV1 = uv1 - uv0;
        Tvec deltaUV2 = uv2 - uv0;

        // Now calculate the tangent but don't normalise to allow for weighted averaging later
        // Bitangent not created as we can extract it via the normal tangent cross product later
        float r = 1.0f / (deltaUV1.x * deltaUV2.y - deltaUV1.y * deltaUV2.x);
        aiVector3D tangent = (deltaPos1 * deltaUV2.y - deltaPos2 * deltaUV1.y) * r;

        // Accumulate un-normalised face tangent into each shared vertex. This will be normalised in a final pass
		vlhsTangents[pIdx0] += tangent;
		vlhsTangents[pIdx1] += tangent;
		vlhsTangents[pIdx2] += tangent;
    }

    // Tangents now set for all mesh vertices. So average each accumulated vertex tangent, then orthogonalise
    for (uint vIdx = 0; vIdx < numVerts; ++vIdx) {

    	aiVector3D& t = vlhsTangents[vIdx];
    	aiVector3D& n = meshNs[vIdx];

        // Normalise weighted tangent to create an average
    	t = t.NormalizeSafe();

	//Orthogonalise based on vertex normal. (This is the Gram-Schmidt process)
	t = t - n * (n * t);
	t.NormalizeSafe();

	// Create bitangent using vector product of the normal and the averaged tangent
	vlhsBitangents[vIdx] = n ^ t;

	// This is not necessary when we have control over model UV creation and can avoid UV symmetry
        // (Also may not be in the right place) 
	if (vlhsBitangents[vIdx] * vlhsBitangents[vIdx] < 0.0f){
		t = t * -1.0f;
	}
    }
}

Cheers.