Comment puis-je orbiter une caméra autour de son point cible?

Je dessine une scène où la caméra se déplace librement dans l'univers. La classe de caméra garde une trace du point de vue (ou de regard ), de la position de la caméra et du vecteur haut. Ces vecteurs / points sont ensuite passés dans gluLookAt.

Le panoramique et le zoom sont presque triviaux à mettre en œuvre. Cependant, je trouve rotation autour de l' oeil à point de d'être beaucoup plus d'un problème. Je veux écrire un Camera.rotate fonction qui prend 2 angles, qui tourne vers le haut / vers le bas et qui tourne à gauche / droite le long d' une sphère imaginaire centrée sur le regard sur le point.

Y a-t-il un moyen facile de faire ceci?

J'ai (brièvement) lu sur les quaternions, mais je voulais voir s'il y avait une solution plus facile étant donné la construction relativement simple de ma scène.

Ce que vous demandez s'appelle la rotation Arcball. Les quaternions ne sont la solution facile que si vous comprenez comment ils fonctionnent. Vous pouvez cependant obtenir la même chose sans quaternions.

Conditions préalables

Savez-vous comment faire pivoter des objets en général? Disons que vous avez un objet à l'origine. Savez-vous comment vous le faites pivoter (indice: multipliez par une matrice de rotation)? Si oui, je suppose que vous savez ce qui se passera si vous traduisez d'abord l'objet, puis le faites pivoter?

Vous devez savoir comment calculer une matrice de rotation à partir de l'angle-axe (simple comme bonjour, regardez la myriade d'équations en ligne, beaucoup d'entre elles vous donnent également le code)

Solution

• Obtenez les vecteurs haut et droit de la caméra . Notez qu'ils doivent être normalisés.
• Obtenez le vecteur du point AF à la caméra (camPosition - Focus). C'est le vecteur que vous allez faire tourner. Appelons ce camFocusVector .
• Décidez à quel point vous souhaitez faire pivoter en lacet / tangage par rapport à la caméra
• Créez deux matrices de rotation. La 1ère matrice de rotation utilisera le haut de la caméra comme axe et angle de lacet que vous avez décidé. La 2ème matrice de rotation utilisera la droite de la caméra comme axe et angle de tangage que vous avez décidé.
• Faites maintenant tourner le camFocusVector avec les nouvelles matrices de rotation. C'est maintenant votre nouvelle position de la caméra par rapport à l'origine. Nous voulons bien sûr que cela soit relatif au point focal ...
• Ajoutez la position du point AF à camFocusVector . C'est maintenant la nouvelle position de votre caméra. Traduisez votre appareil photo en conséquence.
• Enfin, demandez à la caméra de se concentrer sur le point AF en appelant votre fonction lookAt ()

Avertissements

Vous devrez rechercher certains cas ou singularités auxquels votre appareil photo cessera de fonctionner. Regarder vers le bas / haut par exemple. Je vais vous laisser comprendre comment y faire face.

EDIT1: Comment recalculer les vecteurs orthonormaux de la caméra

Vous connaissez déjà la direction de la caméra ((cameraPos - focusPoint) .normalize ()). Supposons maintenant que le haut de votre appareil photo soit + Y (ou w / e l'axe actuel de votre monde est ... c'est à vous de décider). Maintenant, traversez simplement la direction avec le haut pour obtenir la bonne . Terminé? Nan! Votre vecteur haut n'est plus orthogonal aux deux autres. Pour résoudre ce problème, croix à droite avec la direction et vous obtenez votre nouvelle place .

Notez que le Gram-Schmidt est vraiment ce qui devrait être utilisé pour orthonormaliser des vecteurs.

Encore une fois, notez les mises en garde car cela ne fonctionnera pas dans certains cas (la direction est parallèle à up par exemple).

Ce dont vous avez besoin est une caméra ArcBall typique, qui est fondamentalement une caméra qui conserve un emplacement cible et vous permet de déplacer la caméra de manière "sphérique" autour de cette cible.

C'est dans XNA mais IIRC J'ai déjà utilisé cette implémentation, et cela a plutôt bien fonctionné:

http://roy-t.nl/index.php/2010/02/21/xna-simple-arcballcamera/

Voici mon code pour tourner autour d'un point, je me suis retrouvé à le réutiliser beaucoup.

float distance;      // Straight line distance between the camera and look at point

// Calculate the camera position using the distance and angles
float camX = distance * -sinf(camAngleX*(M_PI/180)) * cosf((camAngleY)*(M_PI/180));
float camY = distance * -sinf((camAngleY)*(M_PI/180));
float camZ = -distance * cosf((camAngleX)*(M_PI/180)) * cosf((camAngleY)*(M_PI/180));

// Set the camera position and lookat point
gluLookAt(camX,camY,camZ,   // Camera position
          0.0, 0.0, 0.0,    // Look at point
          0.0, 1.0, 0.0);   // Up vector

Cet algorithme très simple pour y parvenir est assez génial:

En étant P le point central sur lequel vous voulez faire pivoter (le point "regardez" ou "cible"):

translate(-P)

rotate horizontal
rotate vertical

translate(P)

Je l'ai utilisé et c'est sympa.

Source trouvée sur le site sœur stackoverflow: /programming/287655/opengl-rotating-a-camera-around-a-point