GLM: Euler Angles to Đệ tứ

Tôi hy vọng bạn biết GL Toán học ( GLM ) vì tôi gặp vấn đề, tôi không thể phá vỡ:

Tôi có một bộ Euler Angles và tôi cần thực hiện phép nội suy trơn tru giữa chúng. Cách tốt nhất là chuyển đổi chúng thành Đệ tứ và áp dụng thuật toán SLERP.

Vấn đề tôi có là làm thế nào để khởi tạo glm :: quancyion với Euler Angles, làm ơn?

Tôi đã đọc Tài liệu GLM nhiều lần, nhưng tôi không thể tìm thấy thích hợp Quaternion constructor signature, điều đó sẽ mất ba Góc Euler. Hàm gần nhất tôi tìm thấy là hàm angleAxis () , lấy giá trị góc và trục cho góc đó. Lưu ý, xin vui lòng, những gì tôi đang tìm si một cách, làm thế nào để phân tích RotX, RotY, RotZ.

Để biết thông tin của bạn, đây là chữ ký hàm angleAxis () được đo lường ở trên :

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

Tôi không quen thuộc với GLM, nhưng trong trường hợp không có chức năng chuyển đổi trực tiếp từ các góc Euler thành các bậc bốn, bạn có thể sử dụng các hàm "xoay quanh một trục" (chẳng hạn như "angleAxis") cho chính nó.

Đây là cách (mã giả):

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;

(Hoặc bạn có thể cần phải thay đổi các bội số bậc bốn xung quanh, tùy thuộc vào thứ tự xoay góc euler của bạn được áp dụng)

Cách khác, từ việc xem qua tài liệu của GLM, có vẻ như bạn có thể chuyển đổi các góc euler -> matrix3 -> quernion như thế này:

toQuat( orient3( EulerAngles ) )

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

Trường hợp anglelà một sânglm::vec3 chứa , ngáp, cuộn tương ứng.

Tái bút Nếu nghi ngờ, chỉ cần đi đến các tiêu đề và nhìn. Định nghĩa có thể được tìm thấy trong glm / gtc / qu Parention.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;    
}

Trường hợp quatlà một typedef nổi cho tquat.

Giải pháp có trong wikipedia: http://en.wikipedia.org/wiki/Conversion_b between_qu Parentions_and_Euler_angles

sử dụng:

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

Các nhà xây dựng cho một bậc bốn, được đưa ra một Euler (trong đó ứng dụng xoay là XYZ hoặc ZYX). Tuy nhiên, đó chỉ là hai trong số sáu kết hợp góc Euler có thể. Bạn thực sự cần phải tìm ra thứ tự các góc Euler được xây dựng khi chuyển đổi sang ma trận biến đổi. Chỉ sau đó giải pháp có thể được xác định.

Ở công ty cũ tôi làm việc, chúng tôi có Z về phía trước (giống như hầu hết các card đồ họa) nên thứ tự ứng dụng là ZYX, và tại công ty hiện tại của tôi trục Y là chuyển tiếp và Z lên, vì vậy đơn đặt hàng ứng dụng của chúng tôi là YZX. Thứ tự này là thứ tự bạn nhân các nhóm bậc bốn của bạn với nhau để tạo ra biến đổi cuối cùng của bạn và thứ tự quan trọng đối với phép quay là phép nhân không giao hoán.

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

fAngle phải bằng radian!