Discussion :

[pavicf]

Bonjour, je me suis inspiré de plusieurs exemples (entre autre ceux fournis avec le SDK de directx) pour réaliser un trackball. Mais j'ai des résultats bizarres.
Lorsque je bouge la souris horizontalement, mon objet tourne autour de l'axe X (donc verticalement) et vice-versa.
Cela devient encore plus bizarre lorsqu'une rotation de 90° a été effectuée autour de l'axe Y, la rotation n'est même plus linéaire à ce moment lorsque je déplace la souris horizontalement.
Sauriez-vous d'où ça peut venir?

J'ai vérifié mon code plusieurs fois mais je ne voie toujours pas d'où vient le problème.

Voici le code

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
        void Rotation2(int x1, int y1, int x2, int y2, float fTrackBallRadius)
        {
            // inspiré de http://www2.lifl.fr/~triquet/tools/trackball.cpp et d'un exemple de DirectX
 
            float xpos1 = (((2.0f * (float)x1) / this.Width) - 1);
            float ypos1 = (((2.0f * (float)y1) / this.Height) - 1);
            float sz1;
 
            float xpos2 = (((2.0f * (float)x2) / this.Width) - 1);
            float ypos2 = (((2.0f * (float)y2) / this.Height) - 1);
            float sz2;
 
            float t;
 
            if ((xpos2 == xpos1) && (ypos2 == ypos1))
                return;
 
            float d2 = (float)Math.Sqrt(xpos1 * xpos1 + ypos1 * ypos1);
 
            if (d2 < fTrackBallRadius * 0.70710678118654752440) // Inside sphere
                sz1 = (float)Math.Sqrt(fTrackBallRadius * fTrackBallRadius - d2 * d2);
            else
            {
                // On hyperbola
                t = fTrackBallRadius / 1.41421356237309504880f;
                sz1 = (t * t) / d2;
            }
 
            d2 = (float)Math.Sqrt(xpos2 * xpos2 + ypos2 * ypos2);
 
            if (d2 < fTrackBallRadius * 0.70710678118654752440) // Inside sphere
                sz2 = (float)Math.Sqrt(fTrackBallRadius * fTrackBallRadius - d2 * d2);
            else                                                 // On hyperbola
            {
                // On hyperbola
                t = fTrackBallRadius / 1.41421356237309504880f;
                sz2 = (t * t) / d2;
            }
 
 
            // Get two points on trackball's sphere
            Vector3 p1 = new Vector3(xpos1, ypos1, sz1);
            Vector3 p2 = new Vector3(xpos2, ypos2, sz2);
 
            // Get axis of rotation, which is cross product of p1 and p2
            Vector3 axis = Vector3.Cross(p1, p2);
            axis.Normalize();
 
            // Calculate angle for the rotation about that axis
            t = Vector3.Length(Vector3.Subtract(p2, p1)) / (2.0f * fTrackBallRadius);
            if (t > +1.0f) t = +1.0f;
            if (t < -1.0f) t = -1.0f;
            float fAngle = (float)(2.0f * Math.Asin(t));
 
            // On calcule les angles de rotation, voire http://jeux.developpez.com/faq/matquat/?page=transformations#Q37
            Vector3 vrot = c3d.RotationObjets;
            vrot.X += fAngle * axis.X;
            vrot.Y += fAngle * axis.Y;
            vrot.Z += fAngle * axis.Z;
}

merci d'avance pour vos réponses.

[pavicf]

bon, je voie que ça n'inspire pas grand monde ce problème...

J'ai pas eu l'occasion de me repencher dessus entre temps, mais bon, je pense que si je trouve une solution j'essayerais de poster ici un tutoriel pour apréhender cette technique, parce que franchement, à part des codes sources et des explications assez vagues et peu concrètes, je n'ai rien trouvé d'autre sur le net.

(A moins que quelqu'un conaisse un tutoriel bien fait à ce sujet, histoire de pas réinventer la roue...)


Non, sérieusement, il n'y a pas quelqu'un sur ce forum qui conaisse cette technique ou qui soit suffisament fort en math pour pouvoir donner une piste à défaut d'un solution au problème? (ou une explication ou une marche à suivre... enfin tout ce qui pourrait fair avancer le sujet)

merci d'avance aux courageux et généreux esprits qui pourraient contribuer à ce post.

[blastou]

Je ne vois pas trop le rapport entre une trackball et directx. Enfin, je n'ai pas de trackball et n'y connais rien dans ce domaine. Mais pourquoi ne pas avoir réutilisé le code dont tu t'es inspiré ?

Mais puisque ton code fait la même chose, sauf que tu fais quoi au juste a la fin ? plus précisement :

Code :

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

Vector3 vrot = c3d.RotationObjets;

est un variable initialisé à quoi ? Au passage, la fonction ne change aucune de tes variables global donc comment tu peux avoir des changements ?
Tu as une solution avec des quaternions (sencé régler les problèmes avec les 90°) pourquoi ne pas les utiliser ?

[pavicf]

Bonjour,

pour ce qui est de l'endroit où j'ai posté ce message, et bien, je ne savais pas vraiment où le mettre: c'est un problème qui concerne la 3D, directX (si si aussi un peu) et les maths..... Donc bon, je me suis dit que ça devrait convenir étant donné que les trackballs sont souvent utilisées en 3D pour les logiciels de visualisation principalement (ou modélisation....).

En ce qui concerne

Code :

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

1
2
 
Vector3 vrot = c3d.RotationObjets;

C'est une variable qui contient les angles de rotation (angles d'Euler) autour de chaque axe du repère en radians, et je ne peux pas vraiment faire autrement, à moins de refaire une grande partie du code (ce que je n'ai pas le temps de faire malheureusement).
Cette variable est ensuite copiée dans c3d.RotationObjets qui contient les axes de rotation à partir desquels j'obitent la matrice de rotation.

J'en tire une matrice de rotation.

Pour les quaternions, ben oui, c'est mieux, mais comme je l'ai dit plus haut, pas possible dans mon cas (pour le moment). En plus, l'exemple de DirectX qui utilisait les quaternions avait tout de même ce problème GimbalLock (bizare soit dit en passant..).

Donc voilà où j'en suis. Ce que j'aimerais surtout pour le moment, c'est comprendre les principes mathématiques sur lesquels repose cette notion de trackbal. Je pense en avoir compris une partie, mais visiblement ce n'est pas suffisant pour pouvoir régler mon problème.