GLM: Euler Açıları ve Kuaterniyon

Umarım GL Mathematics'i ( GLM ) biliyorsunuzdur çünkü bir sorunum var, kıramıyorum:

Bir dizi Euler Açısı var ve aralarında düzgün enterpolasyon yapmam gerekiyor . En iyi yol onları Kuaterniyonlara dönüştürmek ve SLERP alrogirmisini uygulamaktır .

Benim sorunum nasıl Euler Açıları ile glm :: quaternion başlatmak , lütfen?

GLM Dokümantasyonunu defalarca okudum , ancak uygun bulamıyorum Quaternion constructor signature, bu üç Euler Açısı alacaktı. Bulduğum en yakın olan , açı değerini ve bu açı için bir ekseni alan angleAxis () işlevidir. Lütfen, ne aradığımı lütfen, nasıl ayrıştırılacağını unutmayın RotX, RotY, RotZ.

Bilginiz için bu, yukarıda belirtilen metnioned angleAxis () işlev imzasıdır :

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

GLM'ye aşina değilim, ama doğrudan Euler açılarından kuaterniyonlara dönüşecek bir fonksiyonun yokluğunda, kendinize "bir eksen etrafında dönme" fonksiyonlarını ("angleAxis" gibi) kullanabilirsiniz.

Bunu nasıl yapacağınız (sözde kod):

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;

(Veya euler açısı rotasyonlarınızın uygulanmaya yönelik sırasına bağlı olarak bu kuaterniyon çarpanlarını değiştirmeniz gerekebilir)

Alternatif olarak, GLM'nin belgelerine bakarak, euler açılarını -> matrix3 -> quaternion'ı şu şekilde dönüştürebileceğiniz anlaşılıyor:

toQuat( orient3( EulerAngles ) )

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

Burada anglea, glm::vec3ihtiva eden zift, sapma, rulo sırasıyla.

PS. Şüpheniz varsa, başlıklara gidin ve bakın. Tanım glm / gtc / quaternion.hpp'de bulunabilir:

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;    
}

quatBir şamandıra typedef nerede tquat.

Çözüm wikipedia'da: http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles

bunu kullanarak:

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

Bir Euler verildiğinde bir kuaterniyon için yapıcılar (rotasyon uygulaması XYZ veya ZYX'dir). Ancak, Euler açılarının olası altı kombinasyonundan sadece ikisi. Dönüştürme matrisine dönüştürürken Euler açılarının hangi sırayla yapıldığını gerçekten bulmanız gerekir. Ancak bundan sonra çözüm tanımlanabilir.

Çalıştığım eski şirkette, Z gibi ileriye (çoğu grafik kartı gibi) sahiptik, bu yüzden uygulama siparişi ZYX ve şu anki şirketimde Y ekseni ileri ve Z yükseldi, bu yüzden uygulama siparişimiz YZX. Bu düzen, son dönüşümünüzü oluşturmak için kuaterniyonlarınızı bir araya getirdiğiniz sıradır ve rotasyonlar için sipariş konuları çarpma işlemlerinin değişmez olmasıdır.

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

fAngle radyan olmalı!