worldTranslation = parentNode.worldTranslation * localTranslation;
worldRotation    = parentNode.worldRotation    * localRotation;
worldScale       = parentNode.worldScale       * localScale;

Это не то, как работает накопление последовательных преобразований. И очевидно, почему бы и нет, если подумать.

Допустим, у вас есть два узла: родительский и дочерний. Родитель имеет локальное вращение на 90 градусов против часовой стрелки вокруг оси Z. Дочерний элемент имеет смещение +5 по оси X. Ну, вращение против часовой стрелки должно привести к +5 по оси Y, да (при условии правосторонней системы координат)?

Но это не так. Ваш localTranslation никогда не подвергается какой-либо ротации.

Это относится ко всем вашим трансформациям. На переводы влияют только переводы, а не масштабы или повороты. Вращения не зависят от переводов. И Т. Д.

Это то, что говорит ваш код, и это не то, как вы должны это делать.

Хранение компонентов ваших матриц в разложенном виде - хорошая идея. То есть иметь отдельные компоненты перемещения, поворота и масштабирования (TRS) — хорошая идея. Это упрощает применение последовательных локальных преобразований в правильном порядке.

Итак, хранить компоненты как матрицы неправильно, потому что это действительно бессмысленно и тратит время и пространство без всякой причины. Перевод — это всего лишь vec3, и от хранения 13 других компонентов ничего не выиграешь. Когда вы накапливаете переводы локально, вы просто добавляете их.

Однако в момент, когда вам нужно накопить окончательную матрицу для узла, вам нужно преобразовать каждую декомпозицию TRS в свою собственную локальную матрицу, а затем преобразовать ее в общее преобразование родителя. , а не отдельные компоненты TRS родителя. То есть вам нужно составить отдельные преобразования локально, а затем умножить их на родительскую матрицу преобразования. В псевдокоде:

function AccumRotation(parentTM)
  local localMatrix = TranslationMat(localTranslation) * RotationMat(localRotation) * ScaleMat(localScale)
  local fullMatrix = parentTM * localMatrix

  for each child
    child.AccumRotation(fullMatrix)
  end
end

Каждый родитель передает свой собственный накопленный поворот дочернему элементу. Корневому узлу задается единичная матрица.

Декомпозиция TRS работает отлично, но она работает только при работе с локальными преобразованиями. То есть преобразования относительно родителя. Если вы хотите повернуть объект в его локальном пространстве, вы применяете кватернион к его ориентации.

Но выполнение преобразования в нелокальном пространстве — это совсем другая история. Если вы хотите, например, применить перевод в мировом пространстве к объекту, к которому применена некоторая произвольная серия преобразований... это нетривиальная задача. На самом деле, это простая задача: вы вычисляете матрицу мирового пространства объекта, затем применяете матрицу переноса слева от нее, затем используете обратную матрицу мирового пространства родителя для вычисления относительного преобразования к родителю.

function TranslateWorld(transVec)
  local parentMat = this->parent ? this->parent.ComputeTransform() : IdentityMatrix
  local localMat = this->ComputeLocalTransform()
  local offsetMat = TranslationMat(localTranslation)
  local myMat = parentMat.Inverse() * offsetMat * parentMat * localMat
end

Значение P^-1OP на самом деле является общей конструкцией. Это значит преобразовать общее преобразование O в пространство P. Таким образом, он преобразует мировое смещение в пространство родительской матрицы. Затем мы применяем это к нашему локальному преобразованию.

myMat теперь содержит матрицу преобразования, которая при умножении на преобразования родителя будет применять transVec, как если бы оно было в мировом пространстве. Это то, что вы хотели.

Проблема в том, что myMat — это матрица, а не разложение TRS. Как вернуться к декомпозиции TRS? Ну... это требует действительно нетривиальной матричной математики. Для этого необходимо выполнить нечто, называемое разложением по единственному числу. И даже после реализации уродливой математики SVD может отказать. Можно иметь неразложимую матрицу.

В системе графа сцены, которую я написал, я создал специальный класс, который фактически был объединением декомпозиции TRS и матрицы, которую она представляет. Вы можете запросить, был ли он разложен, и если это так, вы можете изменить компоненты TRS. Но как только вы попытались присвоить ей непосредственно значение матрицы 4x4, она стала составной матрицей, и вы больше не могли применять локальные декомпозированные преобразования. Я даже никогда не пытался внедрить SVD.

О, вы могли бы накапливать в нем матрицы. Но последовательное накопление произвольных преобразований не даст того же результата, что и декомпозированные модификации компонентов. Если вы хотите повлиять на вращение, не затрагивая предыдущие переводы, вы можете сделать это, только если класс находится в декомпозированном состоянии.

В любом случае, в вашем коде есть несколько правильных идей, но есть и очень неправильные. Вам нужно решить, насколько важно иметь декомпозицию TRS по сравнению с тем, насколько важна возможность применять нелокальное преобразование.

Я нашел ответ Никола Боласа несколько полезным, хотя было еще несколько деталей, которые мне не были так понятны. . Но этот ответ помог мне увидеть нетривиальную природу проблемы, над которой я работал, поэтому я решил все упростить.

Простое решение — всегда в родительском пространстве

Я удалил Node.TransformSpace, чтобы упростить проблему. Все преобразования теперь применяются относительно родительского пространства Node, и все работает как положено. Изменения структуры данных, которые я намеревался выполнить после того, как все заработает (например, замена локальных матриц преобразования/масштабирования для простых векторов), также теперь на месте.

Краткое изложение обновленной математики следует.

Обновленный перевод

Позиция Node теперь представлена ​​объектом Vector3, а Matrix4 строится по запросу (см. далее).

void translate(Vector3 tv /*, TransformSpace relativeTo */):
    localPosition += tv;

Обновленная ротация

Вращения теперь содержатся в Matrix3, то есть в матрице 3x3.

void rotate(Angle angle, Vector3 axis /*, TransformSpace relativeTo */):
    localRotation *= RotationMatrix3(angle, axis);

Я все еще планирую взглянуть на кватернионы позже, после того, как смогу убедиться, что мои преобразования кватернионов ‹=> верны.

Обновленное масштабирование

Как и позиция Node, масштабирование теперь также является объектом Vector3:

void scale(Vector3 sv):
    localScale *= sv;

Обновленные вычисления локального/мирового преобразования

Следующее обновляет преобразования мира Node относительно его родителя Node, если таковые имеются. Проблема здесь была устранена путем удаления ненужной конкатенации с полным преобразованием родителя (см. Исходный пост).

void updateTransforms():
    if parentNode != null:
         worldRotation = parent.worldRotation * localRotation;
         worldScale    = parent.worldScale    * localScale;
         worldPosition = parent.worldPosition + parent.worldRotation * (parent.worldScale * localPosition);
    else:
        derivedPosition = relativePosition;
        derivedRotation = relativeRotation;
        derivedScale    = relativeScale;

    Matrix4 t, r, s;

    // cache local/world transforms
    t = TranslationMatrix4(localPosition);
    r = RotationMatrix4(localRotation);
    s = ScalingMatrix4(localScale);
    localTransform = t * r * s;

    t = TranslationMatrix4(worldPosition);
    r = RotationMatrix4(worldRotation);
    s = ScalingMatrix4(worldScale);
    worldTransform = t * r * s;

Основная проблема заключается в том, как решить проблему коммутирующей матрицы.

Предположим, у вас есть матрица X и произведение матриц ABC. И предположим, что вы хотите умножить найти такое Y, что

X*A*B*C = A*B*Y*C

или наоборот.

Предполагая, что матрицы не являются сингулярными, сначала исключите общие члены:

X*A*B = A*B*Y

Далее изолировать. Отслеживая левое и правое, умножьте на инверсии:

A^-1*X*A*B = A^-1 *A *B *Y
A^-1*X*A*B = B *Y
B^-1*A^-1*X*A*B = Y

или в случае, когда у вас есть Y, но вы хотите X:

X*A*B *B^-1 *A^-1 = A*B*Y*B^-1 *A^-1
X = A*B*Y*B^-1 *A^-1

Вышеупомянутое является лишь частным случаем общего правила:

X*A = A*Y

Означает

X=A*Y*A^-1
A^-1*X*A=Y

С примечанием, что (A*B)^-1 = B^-1 * A^-1.

Эта процедура позволяет вам изучить цепочку преобразований и задать вопрос «Я хочу применить преобразование в определенном месте, но сохранить его, применив в другом месте», что является сутью вашей проблемы.

Цепочка матриц, с которой вы работаете, должна включать все преобразования — переносы, повороты, масштабы, а не только преобразования одного и того же типа, поскольку решение для X * B = B * Y не дает решения для X * A * B = A * B * Y.