Discussion :

[MrDuChnok]

Bonjour,

J'ai un petit soucis de rotation d'objets. J'ai un objet à l'écran, je peux le faire tourner dans tous les sens sur lui même. J'utilise les quaternions pour ne pas que mes axes s'emmelent lors des rotations en séries.
Jusque là tout va bien.
Maintenant j'aimerai qu'automatiquement mon objet effectue une certaine rotation d'une position à l'autre.
En gros j'ai un mesh 3D que j'aimerai, suite à plein de rotations, repositionner vers une certaine rotation. (le devant face à la caméra, le haut face à la caméra, etc.).
J'ai donc essayé d'utilisé les "slerp" pour effectuer une transition douce entre deux quaternions (la courante, et la destination). Mais de temps en temps j'ai des tranformations pas jolie jolie... Le mesh qui se déforme dans tous les sens, puis qui finalement se positionne bien. Mais entre les deux c'est pas beau.
Mais j'arrive pas du tout à voir d'où proviendrais mon erreur. J'aurai pas dû utiliser les quaternions ? les slerps ? une erreur de code ?
Bref, si vous avez des pistes ça serais cool.

Merci d'avance.

J'ai utilisé ce code pour le slerp :

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
Quaternion Slerp( const Quaternion& lhs, const Quaternion& rhs, float t )
{
   float cosAlpha = lhs.Dot( rhs );
   Quaternion r = rhs;
 
   if( cosAlpha < 0.0f )
   { // if cos(alpha) is positive, then the path from q1 to q2 is shorter.
       r = -1.0f*r;
   }
   cosAlpha = lhs.Dot( r );
 
   float alpha = acos( cosAlpha );
   if( fabs( alpha ) < epsilon )
   { //< these quaternions are too close to slerp between.
       return lhs;
   }
   float a = sin( ( 1.0f - t ) * alpha ) / sin( alpha );
   float b = sin( t*alpha ) / sin( alpha );
   Quaternion q = a*lhs + b*r;
 
   q.Normalize(); //< we want a unit quaternion
   return q;
}

[LittleWhite]

Bonjour,

Pour les transformations étranges, c'est souvent un problème sur les matrices de transformation. Certes cela peut venir du Quaternion. Mais comme premier coup d'oeil, je n'ai rien vu de spécial.

Je vous conseille d'afficher les valeurs de vos variables pour un débuggage rapide. Ainsi qu'un t qui peut être controllé à la main ( ça ne fait pas de mal )

[Robxley]

Si j'ai bien compris en faite tu as une orientation A de ton Mesh et tu voudrais que ton objet se trouve dans l'orientation B avec une transition de l'un à l'autre.

C'est de l'interpolation de quaternion/matrice de rotation, si ca peut t'aider, il y a un lien sur developpez.com dans la faq sur les quaternions avec le dernier example qui traite de l'interpolation entre 2 quaternions :
http://jeux.developpez.com/faq/matqu...ge=quaternions.

Si non pour le slerp j'ai juste survolé de temps à autre cette méthode, je me souviens que les quaternions de départ doivent être normalisés ce que ne vérifie pas ta fonction Slerp que tu as posté. Après je sais pas si c'est fait ailleurs dans ton programme.

Vérifie bien que les quaternions qui sont passés en paramètre soit bien normalisé.

[MrDuChnok]

Merci de vos intérêts pour mon problème.
Je vais de le résoudre à l'instant,
J'ai tester une autre fonction de slerp, et là ce coup ci, ça fonctionne bien. La rotation s'effectue bien dans le bon sens (le plus court afin d'arriver à la position finale), donc c'est tout bon.

Pour info, voici le code utilisé :

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
44
45
46
47
 public Quaternion slerp(Quaternion q1, Quaternion q2, float t) {
        // Create a local quaternion to store the interpolated quaternion
        if (q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w) {
            this.set(q1);
            return this;
        }
 
        float result = (q1.x * q2.x) + (q1.y * q2.y) + (q1.z * q2.z)
                + (q1.w * q2.w);
 
        if (result < 0.0f) {
            // Negate the second quaternion and the result of the dot product
            q2.x = -q2.x;
            q2.y = -q2.y;
            q2.z = -q2.z;
            q2.w = -q2.w;
            result = -result;
        }
 
        // Set the first and second scale for the interpolation
        float scale0 = 1 - t;
        float scale1 = t;
 
        // Check if the angle between the 2 quaternions was big enough to
        // warrant such calculations
        if ((1 - result) > 0.1f) {// Get the angle between the 2 quaternions,
            // and then store the sin() of that angle
            float theta = FastMath.acos(result);
            float invSinTheta = 1f / FastMath.sin(theta);
 
            // Calculate the scale for q1 and q2, according to the angle and
            // it's sine value
            scale0 = FastMath.sin((1 - t) * theta) * invSinTheta;
            scale1 = FastMath.sin((t * theta)) * invSinTheta;
        }
 
        // Calculate the x, y, z and w values for the quaternion by using a
        // special
        // form of linear interpolation for quaternions.
        this.x = (scale0 * q1.x) + (scale1 * q2.x);
        this.y = (scale0 * q1.y) + (scale1 * q2.y);
        this.z = (scale0 * q1.z) + (scale1 * q2.z);
        this.w = (scale0 * q1.w) + (scale1 * q2.w);
 
        // Return the interpolated quaternion
        return this;
    }