Discussion :

[zabibof]

Bien le bonjour,
J'essaie actuellement d'implémenter une classe Camera dont voici la definition:

Code C++ :

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
 
class Camera
{
public:
	Camera();
 
	void moveSurRight(float);        //deplacement sur _rightVector 
	void moveSurUp(float);           //deplacement sur _upVector
	void moveSurForward(float);    //deplacement sur _forwardVector
 
	void rotSurRight(float);      //rotation autour de _rightVector
	void rotSurUp(float);         //rotation autour de _upVector
	void rotSurForward(float);  //rotation autour de _forwardVector
 
	void lookAt();           
protected:
        void setupTargetPoint();   //calcul le point de focus  
 
	Vector3<float> _forwardVector;
	Vector3<float> _rightVector;
	Vector3<float> _upVector;
	Vector3<float> _cameraPosition;
	Vector3<float> _targetPoint;      //point de focus
};

et l'implémentation, le camera n'est soumis à aucune contrainte physique:

Code C++ :

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
44
45
46
47
48
49
50
51
52
53
54
55
 
//on epargne le constructeur
 
void Camera::moveSurRight(float speed)
{
      _cameraPosition += _rightVector*speed;
}
 
void Camera::moveSurUp(float speed)
{
      _cameraPosition += _upVector*speed;
}
 
void Camera::moveSurForward(float speed)
{
      _cameraPosition += _forwardVector*speed;
}
 
void Camera::rotSurRight(float angle)
{
      Matrix4 transfMatrix;
      transfMatrix.setRotation(_rightVector,angle);
      _upVector=transformVector3<float>(_upVector,transfMatrix);
      _forwardVector=transformVector3<float>(_forwardVector,transfMatrix);
}
 
void Camera::rotSurUp(float angle)
{
      Matrix4 transfMatrix;
      transfMatrix.setRotation(_upVector,angle);
      _rightVector=transformVector3<float>(_rightVector,transfMatrix);
      _forwardVector=transformVector3<float>(_forwardVector,transfMatrix);
}
 
void Camera::rotSurForward(float angle)
{
      Matrix4 transfMatrix;
      transfMatrix.setRotation(_forwardVector,angle);
      _rightVector=transformVector3<float>(_rightVector,transfMatrix);
      _upVector=transformVector3<float>(_upVector,transfMatrix);
}
 
void Camera::setupTargetPoint()
{
      _targetPoint = _cameraPosition + _forwardVector;
}
 
void Camera::lookAt()
{
      setupTargetPoint();
      glMatrixMode(GL_MODELVIEW);
      glLoadIdentity();
      gluLookAt(_cameraPosition._x,_cameraPosition._y,_cameraPosition._z
              ,_targetPoint._x,_targetPoint._y,_targetPoint._z,0,1,0);
}

1- Quand on pousse un peut la camera (long déplacement,...), ça déconne; surtout sur la rotation autour de _rightVector, quand on approche de l'angle droit, les rotations sur cette axe sont bloqués et les autres mouvements sont complètements dérèglés.
Est-ce à cause des nombres flottants ou c'est moi qui n'a vraiment rien compris à la géométrie dans l'espace?
2- Est-ce une bonne façon d'implémenter une camera? Sinon, comment dois-je m'y prendre?

Bon, j'enfile mon casque, je met un plastron, quelques abdos, allez-y, ne retenez pas vos coups, je suis prêt.

[Happy]

Salut,

Je suis vraiment désolé, le temps ne me permets de regarder ton code pour éventuellement trouver le problème, mais si tu souhaite avoir une solution ( base ) simple à implémenter, cependant en se passant de gluLookAt() il y a un petit exemple avec sinus et cosinus ici.

[zabibof]

Ahhh! Enfin quelqu'un.
Merci d'avoir répondu, et aussi pour le lien. En fait, j'avais déjà fait un camera comme celui-là mais je voulais comparer avec la solution matricielle et vectorielle.

[deadalnix]

A prioris tu utilises les angles d'euler, et c'est eux qui te causent un probleme speciallement quand un de tes rotation avoisine les 90° . Tu devrait plutot utiliser des matrices rotation ou bien des quaternions pour eviter ce probleme.

[N_I_C_S]

Le problème, c'est que tu ne transforme que 2 axes dans tes méthodes de rotation, cad que tu ne tiens pas compte des appels précédents. Par ex. tu fais un rotSurUp, tu transforme right et forward. Après, si tu fais un rotSurRight, tu ne touche plus au right qui a été transformé avant. Il faut au moins que tu bouge tes 3 vecteurs dans les 3 méthodes de rotation.
Sinon, dans l'idéal, c'est vrai qu'il vaut mieux faire des quaternions, ou au moins calculer les 3 rotations en une seule matrice (angles d'Euler).

[zabibof]

Merci pour ces réponses, c'est trop aimable.

Le problème, c'est que tu ne transforme que 2 axes dans tes méthodes de rotation, cad que tu ne tiens pas compte des appels précédents. Par ex. tu fais un rotSurUp, tu transforme right et forward. Après, si tu fais un rotSurRight, tu ne touche plus au right qui a été transformé avant. Il faut au moins que tu bouge tes 3 vecteurs dans les 3 méthodes de rotation.

Je ne comprends pas quand tu dis qu'il faut bouger les 3 vecteurs dans les trois méthodes de rotation, normalement, l'axe sur lequel on tourne ne bouge pas.

Sinon, dans l'idéal, c'est vrai qu'il vaut mieux faire des quaternions

Je pense aussi, mais j'aimerais d'abord en finir avec ce problème.

[N_I_C_S]

Ca y est, j'ai compris !!!
Oublie ce que j'ai écrit, et essaye de mettre le vecteur correspondant à ta méthode dans les transfMatrix.setRotation(_rightVector,angle), pas des _rightVector partout.

[zabibof]

Oublie ce que j'ai écrit, et essaye de mettre le vecteur correspondant à ta méthode dans les transfMatrix.setRotation(_rightVector,angle), pas des _rightVector partout.

Oups, désolé, j'ai fait de bêtes copier/coller quand j'ai ecrit le message, mais rassure-toi, dans mon code, j'ai bien le bon vecteur dans setRotation.
Donc, j'EDIT le premier message.

[N_I_C_S]

Dans ce cas, le problème est peut-être au niveau des matrices. Comment est implémenté transfMatrix.setRotation ?

[zabibof]

OK! Voici donc l'implementation de Matrix4::setRotation()

Code C++ :

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
 
inline void Matrix4::setRotation(const Vector3<float>& axis,float angle)
{
	float sinus = (float)sin(angle*RADIAN);
	float cosinus = (float)cos(angle*RADIAN);
 
	float _1_moins_cosinus = 1-cosinus;
 
	//	1ère colonne
	_matrix[0] = axis._x * axis._x * _1_moins_cosinus + cosinus;
	_matrix[1] = axis._y * axis._x * _1_moins_cosinus + axis._z * sinus;
	_matrix[2] = axis._x * axis._z * _1_moins_cosinus - axis._y * sinus;
	_matrix[3] = 0;
	//	2ème colonne
	_matrix[4] = axis._x * axis._y * _1_moins_cosinus - axis._z * sinus;
	_matrix[5] = axis._y * axis._y * _1_moins_cosinus + cosinus;
	_matrix[6] = axis._y * axis._z * _1_moins_cosinus - axis._x * sinus;
	_matrix[7] = 0;
	//	3ème colonne
	_matrix[8] = axis._x * axis._z * _1_moins_cosinus + axis._y * sinus;
	_matrix[9] = axis._y * axis._z * _1_moins_cosinus - axis._x * sinus;
	_matrix[10]= axis._z * axis._z * _1_moins_cosinus + cosinus;
	_matrix[11]= 0;
	//	4ème colonne
	_matrix[12]= 0;	
	_matrix[13]= 0;	
	_matrix[14]= 0;	
	_matrix[15]= 1;
}

[N_I_C_S]

Ouais...
Effectivement, ça doit poser problème. Ta matrice est une espèce de pseudo-empilement de rotations 2D qui ne doit pas vraiment marcher, et surtout pas pour un axe quelconque! C'est du radotage, mais pour tourner autour d'un axe quelconque, la méthode incontournable c'est...les quaternions! C'est simple comme bonjour de transformer un axe et un angle en matrice (regarde sur http://jeux.developpez.com/faq/matquat/ section Quaternions), et je pense que c'est le plus adapté à ce que tu veux faire. C'est le plus adapté un peu pour tout, d'ailleurs.

[zabibof]

Merci pour ton aide, je pense que je vais laissé tomber, je ne vais pas m'entêter là dessus et passer tout de suite au quaternions. Bon, je vais mettre .
à tous.