¿Cómo puedo orbitar una cámara sobre su punto objetivo?

Estoy dibujando una escena en la que la cámara se mueve libremente por el universo. La clase de cámara realiza un seguimiento del punto de vista (o vista ), la posición de la cámara y el vector hacia arriba. Estos vectores / puntos se pasan a gluLookAt.

Pan y zoom son casi triviales de implementar. Sin embargo, yo estoy encontrando rotación alrededor del vistazo a punto de ser mucho más de un problema. Quiero escribir una función Camera.rotate que toma 2 ángulos, uno que gira hacia arriba / abajo y otro que gira hacia la izquierda / derecha a lo largo de una esfera imaginaria que se centra en el punto de mira .

¿Hay una forma fácil de hacer esto?

Leí (brevemente) sobre los cuaterniones, pero quería ver si había una solución más fácil dada la construcción relativamente simple de mi escena.

Lo que está pidiendo se llama rotación de Arcball. Los cuaterniones son la solución fácil solo si comprende cómo funcionan. Sin embargo, puede lograr lo mismo sin cuaterniones.

Prerrequisitos

¿Sabes cómo rotar objetos en general? Digamos que tienes un objeto en el origen. ¿Sabes cómo lo giras (pista: multiplica por una matriz de rotación)? En caso afirmativo, supongo que sabe lo que sucederá si traduce el objeto primero y luego lo gira.

Debe saber cómo calcular una matriz de rotación a partir del eje angular (fácil como un pastel, mire la miríada de ecuaciones en línea, muchas de ellas también le dan el código)

Solución

• Obtener de la cámara hacia arriba y la derecha vectores. Tenga en cuenta que deben normalizarse.
• Obtenga el vector desde el punto de enfoque a la cámara (camPosition - Focus). Este es el vector que vas a rotar. Llamemos esto camFocusVector .
• Decida cuánto desea rotar en guiñada / inclinación en relación con la cámara
• Crea dos matrices de rotación. La primera matriz de rotación usará la parte superior de la cámara como el eje y el ángulo de guiñada que usted decidió. La segunda matriz de rotación usará la derecha de la cámara como eje y paso de ángulo que se decidió.
• Ahora gire el camFocusVector con las nuevas matrices de rotación. Esta es ahora su nueva posición de la cámara en relación con el origen. Por supuesto, queremos que sea relativo al punto de enfoque ...
• Agregue la posición del punto de enfoque a camFocusVector . Esta es ahora la nueva posición de su cámara. Traduce tu cámara en consecuencia.
• Finalmente, pídale a la cámara que enfoque el punto de enfoque llamando a su función lookAt ()

Advertencias

Tendrá que buscar ciertos casos o singularidades en los que su cámara dejará de funcionar. Mirando hacia abajo / arriba, por ejemplo. Te dejaré descubrir cómo lidiar con eso.

EDITAR1: Cómo recalcular los vectores ortonormales de la cámara

Ya conoce la dirección de la cámara ((cameraPos - focusPoint) .normalize ()). Ahora suponga que su cámara está arriba + Y (o w / e el eje arriba actual de su mundo es ... eso depende de usted). Ahora simplemente cruce la dirección con la flecha hacia arriba para obtener la derecha . ¿Hecho? No! Su vector ascendente ya no es ortogonal a los otros dos. Para corregir esto, cruz derecha con dirección y se obtiene su nuevo arriba .

Tenga en cuenta que el Gram-Schmidt es realmente lo que debe usarse para ortonormalizar vectores.

Nuevamente, tome nota de las advertencias ya que esto no funcionará en algunos casos (la dirección es paralela a arriba, por ejemplo).

Lo que necesita es una cámara ArcBall típica, que es básicamente una cámara que mantiene una ubicación de destino y le permite mover la cámara de forma "esférica" ​​alrededor de ese objetivo.

Está en XNA pero en IIRC. He usado esta implementación antes, y funcionó bastante bien:

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

Aquí está mi código para girar alrededor de un punto, me encontré reutilizándolo mucho.

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

Este algoritmo muy simple para lograrlo es bastante impresionante:

Siendo P el punto central sobre el que desea rotar (el punto "mirar" u "objetivo"):

translate(-P)

rotate horizontal
rotate vertical

translate(P)

Lo usé y es agradable.

Fuente encontrada en el stackoverflow del sitio hermano: /programming/287655/opengl-rotating-a-camera-around-a-point