вопрос, сочетающий 2 угла Эйлера с GLM

Как ОП уже подозревал: реализация EulerRotate() неправильно. Это должно быть вместо:

glm::vec3 EulerRotate(const glm::vec3& p, const glm::vec3& euler)
{
return glm::rotateX(glm::rotateY(glm::rotateZ(p, glm::radians(euler.z)),
glm::radians(euler.y)), glm::radians(euler.x));
}

который также может быть записан (более читабельно) как:

glm::vec3 EulerRotate(const glm::vec3& p, const glm::vec3& euler)
{
const glm::vec3 p1 = glm::rotateZ(p, glm::radians(euler.z));
const glm::vec3 p2 = glm::rotateY(p1, glm::radians(euler.y));
const glm::vec3 p3 = glm::rotateX(p2, glm::radians(euler.x));
return p3;
}

Матрица преобразования, соответствующая Эйлеровы углы можно разделить так:

M_Rxyz знак равно M_гХ · M_Ry · M_RZ

и поэтому:

P ‘= M_Rxyz · P = M_гХ · M_Ry · M_RZ · П

Это

P ‘= P вращается вокруг Z, вращается вокруг Y, вращается вокруг X.

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

Я подготовил образец, чтобы продемонстрировать это. Как у меня не было glm под рукой (и не хотел устанавливать его на моей стороне), я использовал собственный код (однажды я подготовился к другому примеру) и попытался максимально приблизиться к коду OP:

#include <iostream>
#include "linMath.h"
double radians(double);
Vec3 degrees(Vec3 angles);
Mat4x4 eulerAngleXYZ(double rX, double rY, double rZ);
void extractEulerAngles(const Mat4x4 &mat, double &rX, double &rY, double &rZ);
Vec3 rotateX(const Vec3 &p, double angle);
Vec3 rotateY(const Vec3 &p, double angle);
Vec3 rotateZ(const Vec3 &p, double angle);

// combines 2 XYZ euler angles given in degrees
Vec3 eulerCombine(const Vec3 &first, const Vec3 &second)
{
const Mat4x4 mat1 = eulerAngleXYZ(radians(first.x), radians(first.y), radians(first.z));
const Mat4x4 mat2 = eulerAngleXYZ(radians(second.x), radians(second.y), radians(second.z));
Vec3 output;
extractEulerAngles(mat2 * mat1, output.x, output.y, output.z);
return degrees(output);
}

// applies the XYZ euler rotation on p
Vec3 eulerRotate(const Vec3 &p, const Vec3 &euler)
{
#ifndef FIX // Theo:
Vec3 output;
output = rotateX(p, radians(euler.x));
output = rotateY(output, radians(euler.y));
output = rotateZ(output, radians(euler.z));
return output;
#else // Dirk:
return rotateX(rotateY(rotateZ(p, radians(euler.z)), radians(euler.y)), radians(euler.x));
#endif // FIX
}

int main()
{
Vec3 euler1(30, 20, 90); // euler angles in degrees
Vec3 euler2(20, 30, 10);
Vec3 euler3 = eulerCombine(euler1, euler2);
Vec3 p(-10, 7, 23);

Vec3 result1 = eulerRotate(eulerRotate(p, euler1), euler2);
Vec3 result2 = eulerRotate(p, euler3);

std::cout << result1.x << " " << result1.y << " " << result1.z << std::endl;
std::cout << result2.x << " " << result2.y << " " << result2.z << std::endl;
// done
return 0;
}

double radians(double angle) { return degToRad(angle); }

Vec3 degrees(Vec3 angles)
{
return Vec3(radToDeg(angles.x), radToDeg(angles.y), radToDeg(angles.z));
}

Mat4x4 eulerAngleXYZ(double rX, double rY, double rZ)
{
return Mat4x4(InitRotX, rX) * Mat4x4(InitRotY, rY) * Mat4x4(InitRotZ, rZ);
}

void extractEulerAngles(const Mat4x4 &mat, double &rX, double &rY, double &rZ)
{
decompose(mat, RotX, RotY, RotZ, rX, rY, rZ);
}

Vec3 rotateX(const Vec3 &p, double angle)
{
const Vec4 p_ = Mat4x4(InitRotX, angle) * Vec4(p, 1.0);
return Vec3(p_.x, p_.y, p_.z);
}

Vec3 rotateY(const Vec3 &p, double angle)
{
const Vec4 p_ = Mat4x4(InitRotY, angle) * Vec4(p, 1.0);
return Vec3(p_.x, p_.y, p_.z);
}

Vec3 rotateZ(const Vec3 &p, double angle)
{
const Vec4 p_ = Mat4x4(InitRotZ, angle) * Vec4(p, 1.0);
return Vec3(p_.x, p_.y, p_.z);
}

Сначала я попробовал код с eulerRotate() функция, которая похожа на порядок преобразования OP и получила следующий вывод:

17.9056 -6.99702 17.5622
17.2369 4.15094 19.0698

Кажется, я правильно воспроизвел проблему ОП. Теперь я определил FIX использовать правильный порядок преобразования и получить следующий вывод:

12.1019 -22.7589 3.68476
12.1019 -22.7589 3.68476

Живая Демо на Wandbox

Теперь оба вычисления дают тот же результат, что и ожидалось.

Я думал, что угол Эйлера XYZ означает, что вы поворачиваете его по оси X, а затем по оси Y, а затем по оси Z.

Не совсем. Как показано выше, это должно интерпретироваться справа налево.