Sto leggendo il libro online "Learning Modern 3D Graphics Programming" di Jason L. McKesson
A partire da ora, sono all'altezza del problema del blocco del gimbal e di come risolverlo usando i quaternioni.
Comunque proprio qui, alla pagina dei Quaternioni .
Parte del problema è che stiamo cercando di memorizzare un orientamento come una serie di 3 rotazioni assiali accumulate. Gli orientamenti sono orientamenti, non rotazioni. E gli orientamenti non sono certamente una serie di rotazioni. Quindi dobbiamo considerare l'orientamento della nave come un orientamento, come una quantità specifica.
Immagino che questo sia il primo punto in cui comincio a confondermi, il motivo è perché non vedo la differenza drammatica tra orientamenti e rotazioni. Inoltre non capisco perché un orientamento non possa essere rappresentato da una serie di rotazioni ...
Anche:
Il primo pensiero a tal fine sarebbe quello di mantenere l'orientamento come matrice. Quando arriva il momento di modificare l'orientamento, applichiamo semplicemente una trasformazione a questa matrice, memorizzando il risultato come nuovo orientamento corrente.
Ciò significa che ogni imbardata, inclinazione e rollio applicati all'orientamento corrente saranno relativi a quell'orientamento corrente. È proprio quello di cui abbiamo bisogno. Se l'utente applica un'imbardata positiva, si desidera che quell'imbardata li ruoti rispetto al punto in cui sono puntati attualmente, non rispetto a un sistema di coordinate fisso.
Il concetto, lo capisco, tuttavia non capisco come se l'accumulo di trasformazioni di matrici sia una soluzione a questo problema, come il codice fornito nella pagina precedente non sia solo questo.
Ecco il codice:
void display()
{
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutil::MatrixStack currMatrix;
currMatrix.Translate(glm::vec3(0.0f, 0.0f, -200.0f));
currMatrix.RotateX(g_angles.fAngleX);
DrawGimbal(currMatrix, GIMBAL_X_AXIS, glm::vec4(0.4f, 0.4f, 1.0f, 1.0f));
currMatrix.RotateY(g_angles.fAngleY);
DrawGimbal(currMatrix, GIMBAL_Y_AXIS, glm::vec4(0.0f, 1.0f, 0.0f, 1.0f));
currMatrix.RotateZ(g_angles.fAngleZ);
DrawGimbal(currMatrix, GIMBAL_Z_AXIS, glm::vec4(1.0f, 0.3f, 0.3f, 1.0f));
glUseProgram(theProgram);
currMatrix.Scale(3.0, 3.0, 3.0);
currMatrix.RotateX(-90);
//Set the base color for this object.
glUniform4f(baseColorUnif, 1.0, 1.0, 1.0, 1.0);
glUniformMatrix4fv(modelToCameraMatrixUnif, 1, GL_FALSE, glm::value_ptr(currMatrix.Top()));
g_pObject->Render("tint");
glUseProgram(0);
glutSwapBuffers();
}Per quanto ne so, non è quello che sta facendo (modificando una matrice su una pila) considerato l'accumulo di matrici, poiché l'autore ha combinato tutte le singole trasformazioni di rotazione in una matrice che viene memorizzata nella parte superiore della pila.
La mia comprensione di una matrice è che vengono utilizzati per prendere un punto relativo a un'origine (diciamo ... il modello) e renderlo relativo a un'altra origine (la fotocamera). Sono abbastanza sicuro che questa sia una definizione sicura, tuttavia mi sembra che manchi qualcosa che mi sta impedendo di comprendere questo problema di blocco del gimbal.
Una cosa che non ha senso per me è: se una matrice determina la differenza relativa tra due "spazi", come mai una rotazione attorno all'asse Y per, diciamo, roll, non inserisce il punto in "roll space "che può quindi essere trasformato ancora una volta in relazione a questo rotolo ... In altre parole, nessuna ulteriore trasformazione a questo punto dovrebbe essere in relazione a questo nuovo" spazio del rotolo "e quindi non avere la rotazione rispetto al precedente" spazio modello "che sta causando il blocco del gimbal.
Ecco perché si verifica il blocco del gimbal giusto? È perché stiamo ruotando l'oggetto attorno agli assi X, Y e Z anziché ruotando l'oggetto attorno ai suoi assi relativi . O mi sbaglio?
Dal momento che apparentemente questo codice che ho collegato non è un accumulo di trasformazioni di matrice, puoi per favore dare un esempio di una soluzione usando questo metodo.
Quindi in sintesi:
- Qual è la differenza tra una rotazione e un orientamento?
- Perché il codice non è collegato in un esempio di accumulo di trasformazioni di matrici?
- Qual è il vero scopo specifico di una matrice, se ho sbagliato?
- Come potrebbe essere implementata una soluzione al problema del blocco gimbal usando l'accumulo di trasformazioni di matrice?
- Inoltre, come bonus: perché le trasformazioni dopo la rotazione sono ancora relative allo "spazio modello?"
- Un altro vantaggio: sbaglio nell'ipotesi che dopo una trasformazione si verificheranno ulteriori trasformazioni rispetto alla corrente?
Inoltre, se non fosse implicito, sto usando OpenGL, GLSL, C ++ e GLM, quindi esempi e spiegazioni in questi termini sono molto apprezzati, se non necessari.
Più sono i dettagli, meglio è!
Grazie in anticipo.
