Discussion :

[Kromagg]

Bonjour à tous

J'implémente une classe Camera qui me permet de me balader dans mon monde à la 1ère personne. Je suis le tutoriel http://tomdalling.com/blog/modern-op...ors-and-input/

Ma classe possède une méthode Update qui fait tout le travail de déplacement-orientation d'une caméra.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
/////////////////////////////////////////////////
void Camera::Update(float dt)
{
	double __posX, __posY;
	glfwGetCursorPos( Window, &__posX, &__posY );
	glfwSetCursorPos( Window, WINDOW_WIDTH * 0.5, WINDOW_HEIGHT * 0.5 );
 
	RotationLeftRight += RotationSpeed * float( __posX - WINDOW_WIDTH * 0.5f ) * dt;
	RotationUpDown += RotationSpeed * float( __posY - WINDOW_HEIGHT * 0.5f  ) * dt;
 
	glm::quat __orientation;
	__orientation = glm::rotate( __orientation, RotationUpDown, VEC3_RIGHT );
	__orientation = glm::rotate( __orientation, RotationLeftRight, VEC3_UP );
 
	glm::quat __inverse = glm::inverse( __orientation );
 
	glm::vec3 __direction = __inverse * VEC3_FORWARD;
	glm::vec3 __right = __inverse * VEC3_RIGHT;
	glm::vec3 __up = __inverse * VEC3_UP;
 
	if ( glfwGetKey( Window, GLFW_KEY_Z ) )
	{
		Position += __direction * MotionSpeed * dt;
	}
 
	if ( glfwGetKey( Window, GLFW_KEY_Q ) )
	{
		Position -= __right * MotionSpeed * dt;
	}
 
	if ( glfwGetKey( Window, GLFW_KEY_S ) )
	{
		Position -= __direction * MotionSpeed * dt;
	}
 
	if ( glfwGetKey( Window, GLFW_KEY_D ) )
	{
		Position += __right * MotionSpeed * dt;
	}
 
	ViewMatrix = glm::lookAt( Position, Position + __direction, __up );
}

D'abord je récupère les positions X et Y de la souris, ensuite je calcule le delta par rapport à la frame précédente et je cumule ce delta dans deux variables qui représente mes des angles de rotation à l'instant T. Je stocke ensuite ces rotations dans un quaternion, puis je calcule les vecteurs direction, right et up. Je fourni enfin ces trois vecteurs à la fonction lookAt pour obtenir la matrice de vue de la caméra.
Il y a cependant quelque chose que je ne comprends pas: pourquoi est-ce que je dois utiliser le quaternion inverse de ma rotation pour que cela fonctionne correctement ? L'auteur l'explique dans son article mais je n'ai pas bien compris le principe

Merci
Kromagg

[Kannagi]

Je suis mauvais en math donc je pourrais pas te dire pourquoi il faut utiliser quaternion inverse.
Par contre j'ai juste 2 remarque a faire , perso et pour un jeu je déconseille de coder hardcore la camera avec directement les input de la lib , l'autre pour la caméra (a la 1ere ou a la 3eme personne) un simple cos/sin suffit pour gérer la rotation de la camera et son deplacement.

D'abord je récupère les positions X et Y de la souris, ensuite je calcule le delta par rapport à la frame précédente et je cumule ce delta dans deux variables qui représente mes des angles de rotation à l'instant T

Je trouve la méthode un poil 'complexe'.
Si cela t’intéresse je considérer la position de x(allant de -1 gauche de ecran a 1 droite de ecran) et y (pareil que x) comme le 'déplacement' d'angles , et ça rendait très bien.

[Kromagg]

Perso et pour un jeu je déconseille de coder hardcore la camera avec directement les input de la lib

En fait je suis les tutoriels OpenGL ici et donc je reste dans du code très simple. Mais pour un vrai jeu oui, je sortirai le code de contrôle de la caméra, pour le mettre dans une classe contrôleur ou quelque chose du genre

Pour la caméra (a la 1ere ou a la 3eme personne) un simple cos/sin suffit pour gérer la rotation de la camera et son deplacement.

J'imagine que tu veux parler des coordonnées sphériques. J'ai implémenté la caméra comme ça dans une version précédente et puis j'ai voulu essayé directement avec les fonctions GLM. Et ça tombe bien parce que j'ai ce problème d'inverse que je ne comprend pas

Si cela t’intéresse je considérer la position de x(allant de -1 gauche de ecran a 1 droite de ecran) et y (pareil que x) comme le 'déplacement' d'angles , et ça rendait très bien.

Je vais essayer ça

[Kannagi]

En fait je suis les tutoriels OpenGL ici et donc je reste dans du code très simple. Mais pour un vrai jeu oui, je sortirai le code de contrôle de la caméra, pour le mettre dans une classe contrôleur ou quelque chose du genre

Après chaqu'un ces priorités surement , mais bon en général quand je commence (avec une nouvelle lib en général , parce que le code risque pas de changée pendant plusieurs années) , je commence par le fenêtrage/événement/fps.

J'imagine que tu veux parler des coordonnées sphériques. J'ai implémenté la caméra comme ça dans une version précédente et puis j'ai voulu essayé directement avec les fonctions GLM. Et ça tombe bien parce que j'ai ce problème d'inverse que je ne comprend pas

Oui je parle bien des coordonnés sphériques , après c'est un peu le choix entre utiliser ces propre formules ou utiliser les formules de quelqu'un autre , tout dépend de ce qu'on veut , on général j'utilise les formules que je ne comprend pas quand j'ai pas le choix , sinon je privilégie les formules simple que je comprend facilement.

Je vais essayer ça

si t'as un souci n'hésite pas ,après il faut évidement que la souris soit capturé par le jeu et au centre de la fenêtre.

[Kromagg]

J'ai oublié de donner l'explication de l'auteur à propos de cette fameuse inversion

The first thing we will look at is the use of glm::inverse. From the last article, we know that matrices transform coordinates. In certain situations, we also want to “untransform” coordinates. That is, we want to take a transformed coordinate and calculate what it used to be, before it was transformed by matrix multiplication. To do this, we need to calculate the inverse of the matrix. An inverse matrix is a matrix that does the exact opposite of another matrix, which means it can “undo” the transformation that the other matrix produces. For example, if matrix A rotates 90° around the Y axis, then the inverse of matrix A will rotate -90° around the Y axis.

When the direction of the camera changes, so does the “up” direction. For example, imagine that there is an arrow pointing out of the top of your head. If you rotate your head to look down at the ground, then the arrow tilts forward. If you rotate your head to look up at the sky, the arrow tilts backwards. If you look straight ahead, then your head is completely “unrotated,” so the arrow points directly upwards. The way we calculate the up direction of the camera is by taking the “directly upwards” unit vector (0,1,0) and “unrotate” it by using the inverse of the camera’s orientation matrix. Or, to explain it differently, the up direction is always (0,1,0) after the camera rotation has been applied, so we multiply (0,1,0) by the inverse rotation, which gives us the up direction before the camera rotation was applied.

The same trick is used to calculate the forward and right directions of the camera.

[LittleWhite]

Bonjour,

Vous suivez la série en cours de traduction/publication ici : http://jeux.developpez.com/tutoriels/OpenGL-moderne/

Après, dans le cas de tomdalling.com, il explique que si on regarde trop vers le haut (rotation à plus de 90° vers le haut), alors, on se "retourne", du coup, lorsque l'on fait la transformation de la caméra, rien ne va plus.
C'est aussi le cas lorsque l'on regarde en bas, il y a un moment, on a la tête entre les jambes et on continue à essayez de regarder plus vers le "bas" (ce qui hypothétiquement, ou, dans un dessin animé), nous permet de continuer à tourner, en passant entre les jambes (et là, ce message devient strange), mais bref, une fois que l'on passe le cap des -90°, la camera est comme "retournée" et donc coup, lorsque l'on essaie d'aller à gauche, ça part à droite, ou inversement.
Lui, il dit :
Pour éviter cela, je zappe la rotation (je l'annule (ou je reviens en arrière) avec le inverse), et je fais mes calculs, tranquille, dans mon coin.

D'autres (la méthode qui serait applicable pour les Tutoriels OpenGL moderne, c'est de dire : ok, on ne va pas plus bas et pas plus haut que (-)89°. Ça marche aussi , doit y avoir pas mal de jeux qui le font