OpenGL Moderne

Lire les informations de la souris est facile :

// Récupère la position de la souris
int xpos, ypos; 
glfwGetMousePos(&xpos, &ypos);

Mais on doit prendre garde à replacer le curseur au centre de l'écran ou il ira en dehors de la fenêtre et vous ne serez plus capable de bouger.

// Réinitialise la position de la souris pour la prochaine image
glfwSetMousePos(1024/2, 768/2);

Maintenant, on calcule nos angles de vision :

// Calcule la nouvelle orientation
horizontalAngle += mouseSpeed * deltaTime * float(1024/2 - xpos ); 
verticalAngle   += mouseSpeed * deltaTime * float( 768/2 - ypos );

On lit ces lignes de droite à gauche :

• 1024/2 - xpos correspond à la distance de la souris par rapport au centre de la fenêtre. Plus grande est la valeur, plus nous voulons tourner ;
• float(…) convertit la position en un nombre à virgule flottante afin que la multiplication soit exacte ;
• mouseSpeed n'est là que pour ralentir ou accélérer les rotations. Modifiez cette valeur à volonté ou laissez l'utilisateur la choisir ;
• += : si vous n'avez pas déplacé la souris, 1024/2 - xpos vaudra 0 et horizontalAngle += 0 ne modifie pas la variable. Si vous aviez un '=' à la place, vous seriez retourné de force à l'orientation d'origine et cela à chaque image, ce qui n'est pas ce que l'on veut.

Maintenant, on peut calculer un vecteur qui représente, dans l'espace monde, la direction vers laquelle on regarde.

// Direction : une conversion de coordonnées sphériques vers coordonnées cartésiennes
glm::vec3 direction( 
    cos(verticalAngle) * sin(horizontalAngle), 
    sin(verticalAngle), 
    cos(verticalAngle) * cos(horizontalAngle) 
);

C'est un calcul standard, mais si vous ne connaissez pas sinus et cosinus, voici une courte explication :

La formule ci-dessus n'est qu'une généralisation pour la 3D.

Maintenant, on souhaite calculer le vecteur « haut » efficacement. Remarquez que le « haut » n'est pas toujours en direction de +Y : si vous regardez vers le bas, par exemple, le vecteur « haut » sera en réalité vertical. Voici un exemple avec deux caméras ayant la même position, la même direction, mais de vecteurs « haut » différents.

Dans ce cas, la seule constante est que le vecteur allant sur la droite est toujours horizontal. Vous pouvez vérifier cela en plaçant votre bras à l'horizontal et en regardant vers le haut, le bas et dans toutes les directions. Voici comment définir le « bon » vecteur « vers la droite » : sa coordonnée Y est 0, car le vecteur est horizontal et ses coordonnées X et Z sont exactement comme dans la figure ci-dessus, mais avec des angles tournés de 90 °, ou Pi / 2 radians.

// vecteur « vers la droite »
glm::vec3 right = glm::vec3( 
    sin(horizontalAngle - 3.14f/2.0f), 
    0, 
    cos(horizontalAngle - 3.14f/2.0f) 
);

On a le vecteur « vers la droite » et une « direction », ou un vecteur vers « l'avant ». Le vecteur « haut » est le vecteur qui est perpendiculaire à ceux-ci. Il y a un outil mathématique pratique qui rend cela très simple : le produit vectoriel.

// Vecteur « haut » : perpendiculaire à la direction et le vecteur vers la droite
glm::vec3 up = glm::cross( right, direction );

Pour se souvenir de ce que fait le produit vectoriel, c'est très simple. Rappelez-vous la règle de la main droite du troisième tutoriel. Le premier vecteur est le pouce ; le second l'index et le résultat est le majeur. C'est très pratique.

Le code est facile à comprendre. D'ailleurs, j'ai utilisé les touches fléchées à la place de aswd, car je suis sur un clavier azerty et aswd correspond à zqsd. C'est aussi différent avec les claviers qwerZ et passons les claviers coréens. Je ne sais même pas quelle disposition les coréens ont, mais je suppose que c'est différent.

// Aller vers l'avant
if (glfwGetKey( GLFW_KEY_UP ) == GLFW_PRESS){ 
    position += direction * deltaTime * speed; 
} 
// Aller vers l'arrière
if (glfwGetKey( GLFW_KEY_DOWN ) == GLFW_PRESS){ 
    position -= direction * deltaTime * speed; 
} 
// Pas à droite
if (glfwGetKey( GLFW_KEY_RIGHT ) == GLFW_PRESS){ 
    position += right * deltaTime * speed; 
} 
// Pas à gauche
if (glfwGetKey( GLFW_KEY_LEFT ) == GLFW_PRESS){ 
    position -= right * deltaTime * speed; 
}

La seule chose particulière est deltaTime. Vous ne souhaitez pas vous déplacer d'une unité chaque image pour la simple raison que :

• si vous avez un ordinateur rapide et que vous exécutez le programme à 60 FPS, vous vous déplacerez de 60 * vitesse unités en une seconde ;
• si vous avez un ordinateur lent et que vous exécutez le programme à 20 FPS, vous vous déplacerez de 20 * vitesse unités en une seconde.

Comme le fait d'avoir un ordinateur plus rapide n'est pas une raison pour se déplacer plus vite, vous devez faire dépendre la distance du « temps depuis la dernière image », ou « deltaTime ».

• si vous avez un ordinateur rapide et que vous exécutez le programme à 60 FPS, vous vous déplacerez de 1 / 60 * vitesse unités en une image, donc 1 * vitesse en une seconde.
• Si vous avez un ordinateur lent et que vous exécutez le programme à 20 FPS, vous vous déplacerez de 1 / 20 * vitesse unités en une image, donc 1 * vitesse en une seconde.

Ce qui est bien mieux. Le deltaTime est très facile à calculer :

double currentTime = glfwGetTime(); 
float deltaTime = float(currentTime - lastTime);

Pour s'amuser, on peut aussi lier la roulette de la souris au champ de vision pour faire rapidement un zoom :

float FoV = initialFoV - 5 * glfwGetMouseWheel();

Le calcul des matrices est maintenant très simple. On utilise les mêmes fonctions que précédemment mais avec les nouveaux paramètres.

// Matrice de projection : champ de vision 45°, ration 4:3, distance d'affiche : 0.1 unit <-> 100 units 
ProjectionMatrix = glm::perspective(FoV, 4.0f / 3.0f, 0.1f, 100.0f); 
// Matrice de vue
ViewMatrix       = glm::lookAt( 
    position,           // La caméra est là
    position+direction, // et regarde ici : à la même position, plus la « direction »
    up                  // la tête est vers le haut (définir à 0,-1,0 pour voir à l'envers) 
);