Jak obrócić obiekt wokół osi wyrównanych do świata?

Mam Vector3, który ma kąt eulera dla każdej osi.

Zwykle, gdy chcę utworzyć macierz obrotu, skorzystam z funkcji takich jak D3DXMatrixRotationX przekazując odpowiedni kąt z mojego wektora obrotu powyżej i pomnożę macierze (ZXY), aby utworzyć ogólną macierz obrotu, która jest używana do utworzenia kompletnej macierzy transformacji obiektu.

Jednak ta metoda spowoduje wygenerowanie zestawu obrotów w przestrzeni obiektów. Oznacza to, że przekazanie wektora (90, 0, 90) do mojej metody spowoduje efektywny obrót w przestrzeni świata o (90, 90, 0).

Czy istnieje sposób, aby zawsze zapewnić, że każdy element mojego wektora obrotu spowoduje obrót wokół odpowiednich osi wyrównanych w przestrzeni świata?

EDYTOWAĆ:

To jest animacja tego, co się obecnie dzieje - chcę sposób na obracanie się wokół niebieskich osi, a nie czerwonych.

EDYCJA 2:

Należy zauważyć, że nie szukam rozwiązania obejmującego kąty Eulera, ale po prostu sposób, w jaki mogę przedstawić transformację wielu obrotów wokół osi świata.

W oparciu o twoje komentarze, wydaje się, że przechowujesz orientację obiektu jako zestaw kątów Eulera i zwiększasz / zmniejszasz kąty, gdy gracz obraca obiekt. Oznacza to, że masz coś takiego jak ten pseudokod:

// in player input handling:
if (axis == AXIS_X) object.angleX += dir;
else if (axis == AXIS_Y) object.angleY += dir;
else if (axis == AXIS_Z) object.angleZ += dir;

// in physics update and/or draw code:
matrix = eulerAnglesToMatrix(object.angleX, object.angleY, object.angleZ);

Jak zauważa Charles Beattie , ponieważ rotacje nie dojeżdżają do pracy, nie zadziała to zgodnie z oczekiwaniami, chyba że gracz obróci obiekt w tej samej kolejności, w której eulerAnglesToMatrix()zastosuje rotacje.

W szczególności rozważ następującą sekwencję obrotów:

1. obróć obiekt o x stopni wokół osi X;
2. obróć obiekt o y stopni wokół osi Y;
3. obróć obiekt o - x stopni wokół osi X;
4. obróć obiekt o - y stopni wokół osi Y.

W naiwnej reprezentacji kąta Eulera, jak zaimplementowano w powyższym pseudokodzie, obroty te zostaną anulowane, a obiekt powróci do pierwotnej orientacji. W prawdziwym świecie tak się nie dzieje - jeśli mi nie wierzysz, weź sześciokątną kostkę lub kostkę Rubika, pozwól x = y = 90 ° i wypróbuj sam!

Jak zauważyłeś we własnej odpowiedzi , rozwiązaniem jest przechowywanie orientacji obiektu jako macierzy obrotu (lub czwartorzędu) i aktualizowanie tej macierzy na podstawie danych wprowadzonych przez użytkownika. Oznacza to, że zamiast powyższego pseudokodu zrobiłbyś coś takiego:

// in player input handling:
if (axis == AXIS_X) object.orientation *= eulerAnglesToMatrix(dir, 0, 0);
else if (axis == AXIS_Y) object.orientation *= eulerAnglesToMatrix(0, dir, 0);
else if (axis == AXIS_Z) object.orientation *= eulerAnglesToMatrix(0, 0, dir);

// in physics update and/or draw code:
matrix = object.orientation;  // already in matrix form!

(Technicznie, ponieważ każda macierz obrotu lub kwaternion może być przedstawiony jako zbiór kątów Eulera, to jest można je stosować do przechowywania orientacji obiektu. Jednak fizycznie były zasada łączenia dwóch kolejnych obrotów, reprezentowane jako kątów Eulera, w pojedynczy obrót jest raczej skomplikowany i zasadniczo sprowadza się do przekształcenia obrotu w macierze / ćwiartki, pomnożenia ich, a następnie przekształcenia wyniku z powrotem w kąty Eulera).

Problem z obrotami polega na tym, że większość ludzi myśli o tym pod kątem kątów Eulera, ponieważ są one łatwe do zrozumienia.

Jednak większość ludzi zapomina o tym, że kąty Eulera to trzy kolejne kąty . Oznacza to, że obrót wokół pierwszej osi spowoduje, że następny obrót będzie związany z pierwszym pierwotnym obrotem, dlatego nie można niezależnie obrócić wektora wokół każdej z 3 osi przy użyciu kątów Eulera.

To bezpośrednio przekłada się na macierze, kiedy mnożymy dwie macierze, można pomyśleć o tym zwielokrotnieniu jako przekształceniu jednej macierzy w przestrzeń drugiej macierzy.

Ma to nastąpić przy 3 dowolnych obrotach sekwencyjnych, nawet przy użyciu czwartorzędów.

Chcę podkreślić fakt, że czwartorzędy nie są rozwiązaniem blokady kłębków. W rzeczywistości blokada drgań zawsze będzie mieć miejsce, jeśli reprezentowałeś kąty Eulera za pomocą czwartorzędów. Problem ten nie jest reprezentacją, problemem jest to , że kolejne etapy 3.

Rozwiązanie?

Rozwiązaniem dla niezależnego obracania wektora wokół 3 osi jest połączenie w jedną oś i jeden kąt, w ten sposób możesz pozbyć się kroku, w którym musisz wykonać sekwencyjne mnożenie. To skutecznie przełoży się na:

Moja macierz obrotu reprezentuje wynik obrotu wokół X, Y i Z.

zamiast interpretacji Eulera

Moja macierz obrotu reprezentuje obrót wokół X, a następnie Y, a następnie Z.

Aby to wyjaśnić, zacytuję z wikipedii Twierdzenie o rotacji Eulera:

Zgodnie z twierdzeniem o rotacji Eulera, każdy obrót lub sekwencja obrotu ciała sztywnego lub układu współrzędnych wokół stałego punktu jest równoważny pojedynczemu obrotowi o zadany kąt θ wokół stałej osi (zwanej osią Eulera), która biegnie przez stały punkt. Oś Eulera jest zazwyczaj reprezentowana przez wektor jednostkowy u →. Dlatego dowolny obrót w trzech wymiarach można przedstawić jako kombinację wektora u → i skalara ar. Czwartorzędy dają prosty sposób zakodowania tej reprezentacji kąta osi w czterech liczbach i zastosowania odpowiedniego obrotu do wektora pozycji reprezentującego punkt względem początku w R3.

Zauważ, że mnożenie 3 macierzy zawsze będzie reprezentowało 3 sekwencyjne obroty.

Teraz, aby połączyć obroty wokół 3 osi, musisz uzyskać jedną oś i pojedyncze kąty, które reprezentują obrót wokół X, Y, Z. Innymi słowy, musisz użyć reprezentacji Oś / Kąt lub czwartorzędu, aby pozbyć się kolejnych obrotów.

Zazwyczaj dokonuje się tego, zaczynając od orientacji początkowej (orientacja może być traktowana jako kąt osi), zwykle reprezentowany jako ćwiartka lub kąt osi, a następnie modyfikując tę ​​orintację, aby reprezentowała orientację docelową. Na przykład zaczynasz od czwartego kwartału tożsamości, a następnie obracasz o różnicę, aby osiągnąć orientację docelową. W ten sposób nie tracisz żadnego stopnia swobody.

Przełączanie kombinacji rotacji z przestrzeni obiektów na przestrzeń świata jest trywialne: wystarczy odwrócić kolejność stosowania rotacji.

W twoim przypadku zamiast mnożenia macierzy Z × X × Ywystarczy tylko wykonać obliczenia Y × X × Z.

Uzasadnienie tego można znaleźć na Wikipedii: konwersja między obrotami wewnętrznymi i zewnętrznymi .

Podam moje rozwiązanie jako odpowiedź, dopóki ktoś nie wyjaśni, dlaczego to działa.

Przy każdym renderowaniu odbudowywałem czwartorzęd przy użyciu kątów zapisanych w wektorze rotacji, a następnie stosując czwartorzęd do mojej ostatecznej transformacji.

Jednak, aby utrzymać go wokół osi świata, musiałem zachować czwartorzęd we wszystkich ramkach i obracać obiekty tylko przy użyciu różnicy kątów, tj.

// To rotate an angle around X - note this is an additional rotation.
// If currently rotated 90, apply this function with angle of 90, total rotation = 180.
D3DXQUATERNION q;
D3DXQuaternionRotation(&q, D3DXVECTOR3(1.0f, 0.0f, 0.0f), fAngle);
m_qRotation *= q; 

//...

// When rendering rebuild world matrix
D3DXMATRIX mTemp;
D3DXMatrixIdentity(&m_mWorld);

// Scale
D3DXMatrixScaling(&mTemp, m_vScale.x, m_vScale.y, m_vScale.z);
m_mWorld *= mTemp;

// Rotate
D3DXMatrixRotationQuaternion(&mTemp, m_qRotation);
m_mWorld *= mTemp;

// Translation
D3DXMatrixTranslation(&mTemp, m_vPosition.x, m_vPosition.y, m_vPosition.z);
m_mWorld *= mTemp;

(Pełne dla czytelności)

Myślę, że dsilva.vinicius próbował dojść do tego punktu.

Będziesz musiał zapisać kolejność obrotów.

Rotating around x 90 then rotate around z 90 !=
Rotating around z 90 then rotate around x 90.

Przechowuj swoją bieżącą macierz obrotu i przedwcześnie każdy obrót, jak tylko się pojawi.

Oprócz odpowiedzi @ concept3d możesz użyć 3 zewnętrznych macierzy obrotu, aby obracać się wokół osi we współrzędnych świata. Cytowanie z Wikipedii :

Obroty zewnętrzne to obroty elementarne, które występują wokół osi stałego układu współrzędnych xyz. System XYZ obraca się, a xyz jest stały. Zaczynając od nakładającego się XYZ xyz, można zastosować kompozycję trzech zewnętrznych obrotów, aby osiągnąć dowolną orientację docelową dla XYZ. Kąty Eulera lub Tait Bryana (α, β, γ) są amplitudami tych rotacji elementarnych. Na przykład orientację docelową można osiągnąć w następujący sposób:

System XYZ obraca się wokół osi Z o α. Oś X znajduje się teraz pod kątem α względem osi X.

System XYZ obraca się ponownie wokół osi X o β. Oś Z znajduje się teraz pod kątem β względem osi Z.

System XYZ obraca się po raz trzeci wokół osi Z o γ.

Macierze rotacji można wykorzystać do przedstawienia sekwencji rotacji zewnętrznych. Na przykład,

R = Z (γ) Y (β) X (α)

reprezentuje kompozycję rotacji zewnętrznych wokół osi xyz, jeśli jest używana do wstępnego zwielokrotnienia wektorów kolumnowych, natomiast

R = X (α) Y (β) Z (γ)

reprezentuje dokładnie ten sam skład, gdy jest używany do pomnożenia wektorów wierszowych.

Zatem potrzebujesz odwrócić kolejność obrotów w stosunku do tego, co zrobiłbyś przy użyciu wewnętrznych (lub lokalnych) obrotów. @Syntac poprosił o obrót zxy, więc powinniśmy wykonać obrót zewnętrzny yxz, aby osiągnąć ten sam wynik. Kod jest poniżej:

Wyjaśnienie wartości macierzy tutaj .

// Init things.
D3DXMATRIX *rotationMatrixX = new D3DXMATRIX();
D3DXMATRIX *rotationMatrixY = new D3DXMATRIX();
D3DXMATRIX *rotationMatrixZ = new D3DXMATRIX();
D3DXMATRIX *resultRotationMatrix0 = new D3DXMATRIX();
D3DXMATRIX *resultRotationMatrix1 = new D3DXMATRIX();

D3DXMatrixRotationX(rotationMatrixX, angleX);
D3DXMatrixRotationY(rotationMatrixY, angleY);
D3DXMatrixRotationZ(rotationMatrixZ, angleZ);

// yx extrinsic rotation matrix
D3DXMatrixMultiply(resultRotationMatrix0, rotationMatrixY, rotationMatrixX);
// yxz extrinsic rotation matrix
D3DXMatrixMultiply(resultRotationMatrix1, resultRotationMatrix0, rotationMatrixZ);

D3DXVECTOR4* originalVector = // Original value to be transformed;
D3DXVECTOR4* transformedVector = new D3DXVECTOR4();

// Applying matrix to the vector.
D3DXVec4Transform(transformedVector, originalVector, resultRotationMatrix1);

// Don't forget to clean memory!

Ten kod jest dydaktyczny, a nie optymalny, ponieważ można ponownie użyć kilku macierzy D3DXMATRIX.