GLM: Euler Winkel zu Quaternion

Ich hoffe du kennst GL Mathematik ( GLM ), weil ich ein Problem habe, ich kann nicht brechen:

Ich habe eine Reihe von Euler-Winkeln und muss zwischen ihnen glatt interpolieren . Am besten konvertieren Sie sie in Quaternions und wenden SLERP alrogirthm an.

Das Problem, das ich habe, ist, wie man glm :: quaternion mit Euler Angles initialisiert , bitte.

Ich habe die GLM-Dokumentation immer wieder gelesen , kann aber nicht feststellen Quaternion constructor signature, dass ich drei Euler-Winkel benötige. Das nächste, was ich gefunden habe, ist die Funktion angleAxis () , die den Winkelwert und eine Achse für diesen Winkel verwendet. Beachten Sie bitte, wonach ich suche und wie ich analysieren kann RotX, RotY, RotZ.

Zu Ihrer Information ist dies die oben angegebene Funktionssignatur von angleAxis () :

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

Ich bin mit GLM nicht vertraut, aber da es keine Funktion gibt, mit der Euler-Winkel direkt in Quaternionen umgewandelt werden können, können Sie die Funktionen "Drehung um eine Achse" (z. B. "angleAxis") selbst verwenden.

Hier ist wie (Pseudocode):

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;

(Oder Sie müssen möglicherweise die Quaternionsmultiplikatoren umschalten, abhängig von der Reihenfolge, in der Ihre Euler-Winkelrotationen angewendet werden sollen.)

Aus der Dokumentation von GLM geht jedoch hervor, dass Sie möglicherweise Euler-Winkel -> Matrix3 -> Quaternion wie folgt konvertieren können:

toQuat( orient3( EulerAngles ) )

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

Wo angleist ein glm::vec3enthaltender Pitch, Yaw, Roll .

PS. Im Zweifelsfall einfach in die Überschriften gehen und nachsehen. Die Definition finden Sie in 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;    
}

Wo quatist ein float typedef für tquat.

Die Lösung befindet sich in Wikipedia: http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles

damit:

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

Konstruktoren für eine Quaternion unter Angabe eines Eulers (wobei die Anwendung der Rotation XYZ oder ZYX ist). Es sind jedoch nur zwei von sechs möglichen Kombinationen von Euler-Winkeln. Sie müssen wirklich herausfinden, in welcher Reihenfolge die Euler-Winkel konstruiert sind, wenn Sie in eine Transformationsmatrix konvertieren. Erst dann kann die Lösung definiert werden.

In der alten Firma, in der ich gearbeitet habe, hatten wir Z als Vorwärts (wie die meisten Grafikkarten), daher lautete die Anwendungsreihenfolge ZYX, und in meiner aktuellen Firma ist die Y-Achse vorwärts und Z nach oben, also lautet unsere Anwendungsreihenfolge YZX. Diese Reihenfolge ist die Reihenfolge, in der Sie Ihre Quaternionen multiplizieren, um Ihre endgültige Transformation zu generieren, und die Reihenfolge ist wichtig für Rotationen, da die Multiplikationen nicht kommutativ sind.

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

Der Winkel muss im Bogenmaß angegeben werden!