Discussion :

[venomelektro]

Bonjour,


je developpe en ce momment un jeu mettant en scene une boule ( jeu de plateforme ) ,

la sphere est un import d un modele 3ds max , c un objet texturé

(voir screenshot --> )



pour la rotation de la sphere quand elle se deplace j ai ecrit ca :

Code :

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

1
2
3
4
 
	float dt10 = deltaTime*10.0f;
	player.rotation.x += player.velocity.z*dt10;
	player.rotation.z += player.velocity.x*dt10;

pour le deplacement vertical (z) c est nickel
mais en x ca ne marche pas a tous les coups ( depend des angles) :

parfois la texture tourne a l envers suivant les angles.

c une bete histoire de trigo mais j arrive pas a trouver la bonne formule , donc si qqun la connait ...

merci

A+

[venomelektro]

Up !

[LeGreg]

J'imagine que z c'est vertical sur ton image et x c'est horizontal.

Il ne faut pas que tu decrives ton mouvement en incremental par rapport à l'angle parce que passé un certain déplacement les angles deviennent non intuitifs (dans ce context simple de déplacement selon deux axes).

En fait la rotation de ta sphère est décrite par les angles selon les axes mais les axes tournent aussi en fonction de la rotation de ta sphère, donc si tu veux tourner par rapport à x dans ton image, si l'axe x a changé de place après avoir appliqué la rotation par rapport à z, il faut transcrire cette rotation selon l'x global dans le nouveau repère modifié. Comme tu le vois ça se mange la queue.

Une solution partielle c'est de passer à la rotation incrémentale à partir de matrices (ou de quaternions mais bon c'est pas une nécessité).
Si ROT0 c'est la rotation au temps zero exprimée sous forme matricielle, alors quand ta sphère s'est déplacée d'un angle (dx,dz) tu calcules la matrice élementaire dROT correspondant à ce déplacement. La rotation effective de ta sphère au temps 1 c'est donc ROT1 = ROT0 * dROT.
L'ordre dx/dz n'a pas trop d'importance si tu gardes dx et dz très petits (proches de zero).

Attention de temps à autre il faut renormaliser/orthogonaliser la matrice pour ne pas se retrouver avec une sphère qui rétrécit ou se déforme selon un axe.

[venomelektro]

Salut,


merci LeGreg pour ces precisions

je vais tenter d implementer ca avec ce que tu m a dit , j ai une classe Quaternion mais je n ai pas encore reussi a trouver comment m en servir pour ce probleme jusqu a present.

Je vais retenter avec les indications que tu viens de me donner

[venomelektro]

Salut,

Attention de temps à autre il faut renormaliser/orthogonaliser la matrice pour ne pas se retrouver avec une sphère qui rétrécit ou se déforme selon un axe.

en fait j ai laissé le probleme de coté depuis quelque temps , j arrive effectivement a avoir un rotation correcte mais par contre je n arrive a a empecher la deformation , j ai trouvé cette formule sur le net mais ca fonctionne pas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 double norm(Matrix &m)
  {
    double res = 0.0;
    for (int r = 0; r<4; r++)
      for (int c = 0; c<4; c++)
	res += m.e[r][c]*m.e[r][c];
 
    return sqrtf((float)res);
  }
 
 
player.RotMat = player.RotMat * ( 1.0f / norm(player.RotMat) );

je crois que la formule est correcte mais tu m a dit ortho normalizer et ca e trouve pas comment faire ..
:


[EDIT]

c bon j ai la formule magique

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
 
 inline void MatrixOrthonormalize(Matrix & matrix)
{
	float fLength = sqrtf((matrix.m11 * matrix.m11) + (matrix.m21 * matrix.m21) + (matrix.m31 * matrix.m31));
	if (fLength > 0.0f)
	{
		fLength = 1.0f / fLength;
		matrix.m11 *= fLength;
		matrix.m21 *= fLength;
		matrix.m31 *= fLength;
	}
 
	fLength = sqrtf((matrix.m12 * matrix.m12) + (matrix.m22 * matrix.m22) + (matrix.m32 * matrix.m32));
	if (fLength > 0.0f)
	{
		fLength = 1.0f / fLength;
		matrix.m12 *= fLength;
		matrix.m22 *= fLength;
		matrix.m32 *= fLength;
	}
 
	matrix.m13 = (matrix.m21 * matrix.m32) - (matrix.m31 * matrix.m22);
	matrix.m23 = (matrix.m31 * matrix.m12) - (matrix.m11 * matrix.m32);
	matrix.m33 = (matrix.m11 * matrix.m22) - (matrix.m21 * matrix.m12);
}

[/EDIT]