Как рассчитать тангенс и бинормаль?

Соответствующие входные данные для вашей проблемы - это координаты текстуры. Касательная и бинормаль - это векторы, локально параллельные поверхности объекта. А в случае отображения нормалей они описывают локальную ориентацию текстуры нормалей.

Таким образом, вам нужно рассчитать направление (в пространстве модели), в котором указывают векторы текстурирования. Допустим, у вас есть треугольник ABC с координатами текстуры HKL. Это дает нам векторы:

D = B-A
E = C-A

F = K-H
G = L-H

Теперь мы хотим выразить D и E через касательное пространство T, U, т. Е.

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' вместе с нормалью вершины как часть геометрии модели (как атрибуты вершины), чтобы мы могли использовать их в шейдере для вычислений освещения. Я повторяю: вы не определяете касательную и бинормаль в шейдере, вы предварительно вычисляете их и сохраняете как часть геометрии модели (как и нормали).

(Обозначения между вертикальными полосами выше - это все матрицы, а не детерминанты, которые обычно используют вертикальные полосы вместо скобок в своих обозначениях.)

Как правило, у вас есть 2 способа создания матрицы TBN: автономный и интерактивный.

• Он-лайн = прямо во фрагментном шейдере с использованием производных инструкций. Эти производные дают вам плоскую основу TBN для каждой точки многоугольника. Чтобы получить гладкую, мы должны повторно ортогонализировать ее на основе заданной (гладкой) вершинной нормали. Эта процедура еще более тяжелая для графического процессора, чем первоначальное извлечение TBN.

  // compute derivations of the world position
  vec3 p_dx = dFdx(pw_i);
  vec3 p_dy = dFdy(pw_i);
  // compute derivations of the texture coordinate
  vec2 tc_dx = dFdx(tc_i);
  vec2 tc_dy = dFdy(tc_i);
  // compute initial tangent and bi-tangent
  vec3 t = normalize( tc_dy.y * p_dx - tc_dx.y * p_dy );
  vec3 b = normalize( tc_dy.x * p_dx - tc_dx.x * p_dy ); // sign inversion
  // get new tangent from a given mesh normal
  vec3 n = normalize(n_obj_i);
  vec3 x = cross(n, t);
  t = cross(x, n);
  t = normalize(t);
  // get updated bi-tangent
  x = cross(b, n);
  b = cross(n, x);
  b = normalize(b);
  mat3 tbn = mat3(t, b, n);
  

• Off-line = подготовить касательную как атрибут вершины. Это труднее получить, потому что это не только добавит еще один атрибут вершины, но также потребует перекомпоновки всех остальных атрибутов. Более того, это не на 100% даст вам лучшую производительность, так как вы получите дополнительную стоимость хранения / передачи / анимации (!) Атрибута вершины vector3.

Математика описана во многих местах (в Google), в том числе в сообщении @datenwolf.

Проблема здесь в том, что две вершины могут иметь одинаковые координаты нормали и текстуры, но разные касательные. Это означает, что вы не можете просто добавить атрибут вершины к вершине, вам нужно разделить вершину на 2 и указать разные касательные для клонов.

Лучший способ получить уникальную касательную (и другие атрибуты) для каждой вершины - сделать это как можно раньше = в экспортере. Там, на этапе сортировки чистых вершин по атрибутам, вам достаточно добавить касательный вектор к ключу сортировки.

В качестве радикального решения проблемы рассмотрите возможность использования кватернионов. Одиночный кватернион (vec4) может успешно представлять тангенциальное пространство заранее определенной степени удобства. Легко поддерживать ортонормированность (включая переход к фрагментному шейдеру), сохранять и при необходимости извлекать нормальные. Дополнительная информация на вики-странице KRI.

Исходя из ответа 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 );

Обычный способ ортогонализации любой матрицы - это процесс Грама – Шмидта:

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

Существует множество способов вычисления касательных, и если редактор карт нормалей не делает это так же, как средство визуализации, вы получите тонкие артефакты. Многие пекари используют алгоритм 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);

(Бинормаль обычно рассчитывается на пиксель, но некоторые пекари дают вам возможность рассчитать ее для каждой вершины и интерполировать. На этой странице есть информация о конкретных программах.)