如何计算正切和副法线？

Question

谈论凹凸贴图、镜面高光以及 OpenGL 着色语言 (GLSL) 中的此类内容，

我有：

• 顶点数组（例如 {0.2,0.5,0.1, 0.2,0.4,0.5, ...}）
• 法线数组（例如 {0.0,0.0,1.0, 0.0,1.0,0.0, ...}）
• 点光源在世界空间中的位置（例如 {0.0,1.0,-5.0}）
• 观察者在世界空间中的位置（例如{0.0,0.0,0.0})（假设观看者位于世界中心）

现在，如何计算每个顶点的副法线和切线？我的意思是，计算双法线的公式是什么，我必须根据这些信息使用什么？关于切线？

无论如何，我都会构建 TBN 矩阵，因此，如果您知道直接根据这些信息构建矩阵的公式，那就太好了！

哦，是的，如果需要的话，我也有纹理坐标。 当我谈论 GLSL 时，如果有一种逐顶点解决方案会很好，我的意思是，这种解决方案不需要一次访问多个顶点信息。

---- 更新-----

我找到了这个解决方案：

vec3 tangent;
vec3 binormal;

vec3 c1 = cross(a_normal, vec3(0.0, 0.0, 1.0));
vec3 c2 = cross(a_normal, vec3(0.0, 1.0, 0.0));

if (length(c1)>length(c2))
{
    tangent = c1;
}
else
{
    tangent = c2;
}

tangent = normalize(tangent);

binormal = cross(v_nglNormal, tangent);
binormal = normalize(binormal);

但我不知道它是否100%正确。

Answer 1

与您的问题相关的输入数据是纹理坐标。切线和副法线是局部平行于对象表面的向量。在法线贴图的情况下，它们描述的是法线纹理的局部方向。

因此，您必须计算纹理向量指向的方向（在模型空间中）。假设您有一个三角形 ABC，其纹理坐标为 HKL。这给了我们向量：

D = B-A
E = C-A

F = K-H
G = L-H

现在我们想用切线空间 T, U 来表达 D 和 E，即

D = F.s * T + F.t * U
E = G.s * T + G.t * U

这是一个有 6 个未知数和 6 个方程的线性方程组，它可以写为

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

求逆 FG 矩阵得到

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

与顶点法线 T 和 U 形成局部空间基，称为切线空间，由矩阵描述

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

从切线空间变换到对象空间。为了进行照明计算，需要与此相反。经过一点练习，我们会发现：

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

对向量 T' 和 U' 进行归一化，将它们称为切线和副法线，我们获得从对象转换到切线空间的矩阵，我们在切线空间中进行照明：

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

我们将 T' 和 U' 存储在一起顶点法线作为模型几何体的一部分（作为顶点属性），以便我们可以在着色器中使用它们进行光照计算。 我再说一遍：您不需要在着色器中确定切线和副法线，您可以预先计算它们并将它们存储为模型几何体的一部分（就像法线一样）。

（上面垂直条之间的符号都是矩阵，绝不是行列式，通常在表示法中使用竖线而不是括号。）

Answer 2

通常，有 2 种生成 TBN 矩阵的方法：离线和在线。

• 在线 = 直接在片段着色器中使用派生指令。这些推导为您提供了多边形每个点的平坦 TBN 基础。为了获得平滑的效果，我们必须根据给定的（平滑）顶点法线重新正交化它。此过程对 GPU 的负担甚至比初始 TBN 提取还要重。

   // 计算世界位置的导数
   vec3 p_dx = dFdx(pw_i);
   vec3 p_dy = dFdy(pw_i);
   // 计算纹理坐标的导数
   vec2 tc_dx = dFdx(tc_i);
   vec2 tc_dy = dFdy(tc_i);
   // 计算初始正切和双正切
   vec3 t = 归一化( tc_dy.y * p_dx - tc_dx.y * p_dy );
   vec3 b = 归一化( tc_dy.x * p_dx - tc_dx.x * p_dy ); // 符号反转
   // 从给定的网格法线获取新的切线
   vec3 n = 归一化(n_obj_i);
   vec3 x = 交叉(n, t);
   t = 交叉（x，n）；
   t = 归一化(t);
   // 获取更新的双切线
   x = 交叉(b, n);
   b = 交叉（n，x）；
   b = 归一化(b);
   mat3 tbn = mat3(t, b, n);
  

• 离线 = 准备切线作为顶点属性。这更难实现，因为它不仅会添加另一个顶点属性，而且还需要重新组合所有其他属性。此外，它不会 100% 为您提供更好的性能，因为您将获得存储/传递/动画（！）vector3 顶点属性的额外成本。

数学在很多地方都有描述（谷歌一下），包括@datenwolf 帖子。

这里的问题是两个顶点可能具有相同的法线和纹理坐标，但切线不同。这意味着您不能只向顶点添加顶点属性，您需要将顶点拆分为 2 并为克隆指定不同的切线。

获得每个顶点唯一的切线（和其他属性）的最佳方法是尽早在导出器中执行此操作。在按属性对纯顶点进行排序的阶段，您只需将切向量添加到排序键即可。

作为该问题的根本解决方案，请考虑使用四元数。单个四元数 (vec4) 可以成功地表示预定义灵活性的切向空间。保持正交（包括传递到片段着色器）、存储和提取法线（如果需要）很容易。如需了解更多信息，请访问 KRI 维基。

Answer 3

根据kvark的回答，我想补充更多的想法。

如果您需要正交化切线空间矩阵，您必须以任何方式做一些工作。
即使您添加切线和副法线属性，它们也会在着色器阶段进行插值
最终它们既没有被标准化，也没有彼此正常化。

假设我们有一个归一化法线向量 n，并且我们有切线t 和副法线b 或者我们可以通过如下推导来计算它们：

// derivations of the fragment position
vec3 pos_dx = dFdx( fragPos );
vec3 pos_dy = dFdy( fragPos );
// derivations of the texture coordinate
vec2 texC_dx = dFdx( texCoord );
vec2 texC_dy = dFdy( texCoord );
// tangent vector and binormal vector
vec3 t = texC_dy.y * pos_dx - texC_dx.y * pos_dy;
vec3 b = texC_dx.x * pos_dy - texC_dy.x * pos_dx;

当然可以使用叉积来计算正交化切空间矩阵，
但这仅适用于右手系统。如果矩阵被镜像（左手系统），它将变成右手系统：

t = cross( cross( n, t ), t ); // orthonormalization of the tangent vector
b = cross( n, t );             // orthonormalization of the binormal vector 
                               //   may invert the binormal vector
mat3 tbn = mat3( normalize(t), normalize(b), n );

在上面的代码片段中，如果切线空间是左手系统，则副法线向量会反转。
为了避免这种情况，必须采取困难的方法：

t = cross( cross( n, t ), t ); // orthonormalization of the tangent vector
b = cross( b, cross( b, n ) ); // orthonormalization of the binormal vectors to the normal vector 
b = cross( cross( t, b ), t ); // orthonormalization of the binormal vectors to the tangent vector
mat3 tbn = mat3( normalize(t), normalize(b), n );

正交化任何矩阵的常见方法是 Gram-Schmidt 过程：

t = t - n * dot( t, n ); // orthonormalization ot the tangent vectors
b = b - n * dot( b, n ); // orthonormalization of the binormal vectors to the normal vector 
b = b - t * dot( b, t ); // orthonormalization of the binormal vectors to the tangent vector
mat3 tbn = mat3( normalize(t), normalize(b), n );

另一种可能性是使用 2*2 矩阵的行列式，该矩阵由纹理坐标 texC_dx、texC_dy 的推导得出，考虑副法向量的方向。这个想法是正交矩阵的行列式是1，正交镜像矩阵的确定行列式是-1。

行列式可以通过 GLSL 函数行列式( mat2( texC_dx, texC_dy ) 计算
或者可以通过公式texC_dx.x * texC_dy.y - texC_dy.x * texC_dx.y计算。

对于正交归一化切空间矩阵的计算，不再需要副法向量和单位向量的计算
可以回避副法向量的归一化（normalize）。

float texDet = texC_dx.x * texC_dy.y - texC_dy.x * texC_dx.y;
vec3 t = texC_dy.y * pos_dx - texC_dx.y * pos_dy;
t      = normalize( t - n * dot( t, n ) );
vec3 b = cross( n, t );                      // b is normlized because n and t are orthonormalized unit vectors
mat3 tbn = mat3( t, sign( texDet ) * b, n ); // take in account the direction of the binormal vector

Answer 4

计算切线的方法有很多种，如果法线贴图烘焙器不采用与渲染器相同的方法，您将得到微妙的伪像。许多面包师使用 MikkTSpace 算法，该算法与片段导数技巧不同。

，如果您有一个使用 MikkTSpace 的程序中的索引网格（并且没有具有相反方向的纹理坐标三角形共享索引），则该算法的困难部分大部分已为您完成，您可以像这样重建切线：

#include <cmath>
#include "glm/geometric.hpp"
#include "glm/vec2.hpp"
#include "glm/vec3.hpp"
#include "glm/vec4.hpp"

using glm::vec2;
using glm::vec3;
using glm::vec4;

void makeTangents(uint32_t nIndices, uint16_t* indices,
                  const vec3 *positions, const vec3 *normals,
                  const vec2 *texCoords, vec4 *tangents) {
  uint32_t inconsistentUvs = 0;
  for (uint32_t l = 0; l < nIndices; ++l) tangents[indices[l]] = vec4(0);
  for (uint32_t l = 0; l < nIndices; ++l) {
    uint32_t i = indices[l];
    uint32_t j = indices[(l + 1) % 3 + l / 3 * 3];
    uint32_t k = indices[(l + 2) % 3 + l / 3 * 3];
    vec3 n = normals[i];
    vec3 v1 = positions[j] - positions[i], v2 = positions[k] - positions[i];
    vec2 t1 = texCoords[j] - texCoords[i], t2 = texCoords[k] - texCoords[i];

    // Is the texture flipped?
    float uv2xArea = t1.x * t2.y - t1.y * t2.x;
    if (std::abs(uv2xArea) < 0x1p-20)
      continue;  // Smaller than 1/2 pixel at 1024x1024
    float flip = uv2xArea > 0 ? 1 : -1;
    // 'flip' or '-flip'; depends on the handedness of the space.
    if (tangents[i].w != 0 && tangents[i].w != -flip) ++inconsistentUvs;
    tangents[i].w = -flip;

    // Project triangle onto tangent plane
    v1 -= n * dot(v1, n);
    v2 -= n * dot(v2, n);
    // Tangent is object space direction of texture coordinates
    vec3 s = normalize((t2.y * v1 - t1.y * v2)*flip);
    
    // Use angle between projected v1 and v2 as weight
    float angle = std::acos(dot(v1, v2) / (length(v1) * length(v2)));
    tangents[i] += vec4(s * angle, 0);
  }
  for (uint32_t l = 0; l < nIndices; ++l) {
    vec4& t = tangents[indices[l]];
    t = vec4(normalize(vec3(t.x, t.y, t.z)), t.w);
  }
  // std::cerr << inconsistentUvs << " inconsistent UVs\n";
}

幸运的是 顶点着色器，它们被旋转到世界空间：

  fragNormal = (model.model * vec4(inNormal, 0)).xyz;
  fragTangent = vec4((model.model * vec4(inTangent.xyz, 0)).xyz, inTangent.w);

然后像这样计算副法线和世界空​​间法线（参见http://mikktspace. com/）：（

  vec3 binormal = fragTangent.w * cross(fragNormal, fragTangent.xyz);
  vec3 worldNormal = normalize(normal.x * fragTangent.xyz +
                               normal.y * binormal +
                               normal.z * fragNormal);

副法线通常按像素计算，但有些面包师允许您选择按顶点计算并插值。此页面包含有关特定程序的信息。）