GLM: Kąty Eulera do czwartorzędu

Mam nadzieję, że znasz GL Mathematics ( GLM ), ponieważ mam problem, nie mogę złamać:

Mam zestaw kątów Eulera i muszę wykonać płynną interpolację między nimi. Najlepszym sposobem jest ich konwersja do Quaternions i zastosowanie alrogirthm SLERP.

Mam problem z inicjowaniem glm :: quaternion za pomocą Euler Angles, proszę?

Wciąż czytam Dokumentację GLM , ale nie mogę znaleźć odpowiedniego Quaternion constructor signature, który zająłby trzy Kąty Eulera. Najbliższą, jaką znalazłem, jest funkcja angleAxis () , która przyjmuje wartość kąta i oś dla tego kąta. Uwaga, proszę, czego szukam, jak analizować RotX, RotY, RotZ.

Dla Twojej informacji jest to powyższa sygnatura funkcji metnioned angleAxis () :

detail::tquat< valType > angleAxis (valType const &angle, valType const &x, valType const &y, valType const &z)

Nie znam GLM, ale przy braku funkcji do bezpośredniej konwersji kątów Eulera na ćwiartki, możesz użyć do tego funkcji „obrotu wokół osi” (takich jak „angleAxis”).

Oto jak (pseudokod):

Quaternion QuatAroundX = Quaternion( Vector3(1.0,0.0,0.0), EulerAngle.x );
Quaternion QuatAroundY = Quaternion( Vector3(0.0,1.0,0.0), EulerAngle.y );
Quaternion QuatAroundZ = Quaternion( Vector3(0.0,0.0,1.0), EulerAngle.z );
Quaternion finalOrientation = QuatAroundX * QuatAroundY * QuatAroundZ;

(Lub może być konieczne przełączenie mnożników czwartorzędu, w zależności od kolejności, w jakiej mają być zastosowane obroty kąta eulera)

Alternatywnie, po przejrzeniu dokumentacji GLM wydaje się, że możesz przekonwertować kąty eulera -> matrix3 -> quaternion w następujący sposób:

toQuat( orient3( EulerAngles ) )

glm::quat myquaternion = glm::quat(glm::vec3(angle.x, angle.y, angle.z));

W przypadku, gdy anglejest glm::vec3zawierającym pak, odchylenie zwijana odpowiednio.

PS. W razie wątpliwości przejdź do nagłówków i spójrz. Definicję można znaleźć w glm / gtc / quaternion.hpp:

explicit tquat(tvec3<T> const & eulerAngles) {
        tvec3<T> c = glm::cos(eulerAngle * value_type(0.5));
    tvec3<T> s = glm::sin(eulerAngle * value_type(0.5));

    this->w = c.x * c.y * c.z + s.x * s.y * s.z;
    this->x = s.x * c.y * c.z - c.x * s.y * s.z;
    this->y = c.x * s.y * c.z + s.x * c.y * s.z;
    this->z = c.x * c.y * s.z - s.x * s.y * c.z;    
}

Gdzie quatjest typ zmiennoprzecinkowy tquat.

Rozwiązanie jest w wikipedii: http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles

używając tego:

sx = sin(x/2); sy = sin(y/2); sz = sin(z/2);
cx = cos(x/2); cy = cos(y/2); cz = cos(z/2);

q( cx*cy*cz + sx*sy*sz,
   sx*cy*cz - cx*sy*sz,
   cx*sy*cz + sx*cy*sz,
   cx*cy*sz - sx*sy*cz ) // for XYZ application order

q( cx*cy*cz - sx*sy*sz,
   sx*cy*cz + cx*sy*sz,
   cx*sy*cz - sx*cy*sz,
   cx*cy*sz + sx*sy*cz ) // for ZYX application order

Konstruktory dla czwartorzędu, biorąc pod uwagę Euler (gdzie zastosowanie obrotu to XYZ lub ZYX). Są to jednak tylko dwie z sześciu możliwych kombinacji kątów Eulera. Naprawdę musisz dowiedzieć się, w jakiej kolejności konstruowane są kąty Eulera podczas konwersji na macierz transformacji. Tylko wtedy można zdefiniować rozwiązanie.

W starej firmie, w której pracowałem, mieliśmy Z jako naprzód (jak większość kart graficznych), więc kolejność aplikacji była ZYX, aw mojej obecnej firmie oś Y jest do przodu, a Z jest w górze, więc nasza kolejność aplikacji to YZX. Ta kolejność to kolejność, w której mnożą się twoje czwartorzędy, aby wygenerować ostateczną transformację, a kolejność ma znaczenie dla rotacji, ponieważ mnożenia nie są przemienne.

vec3 myEuler (fAngle[0],fAngle[1],fAngle[2]);
glm::quat myQuat (myEuler);

fAngle musi być w radianach!