[DelK]

*voulait faire un script de porte*

*regarde des scripts de portes libres*



J'avoue que ça fait plusieurs jour que j'essaie de comprendre le système de rotations pour scripter des mouvements simples, mais que j'ai toujours l'impression de pas avancer voir de reculer à chaque pas en avant.


Quelqu'un qui peut expliquer le principe dans les grandes lignes, définir "Euler", etc...?

[Enaery]

je ne saurais pas dire exactement comment ca fonctionne au niveau script mais, j'ai déjà vu deux mode de fonctionnement :
Une porte composé de deux prim, un cylindre, et un panneau accrocher par une de ses tranches au cylindre, c'est le cylindre qui tourne, le panneau faisant office de porte, suit le mouvement du cylindre
Ou alors, et la je ne sais pas comment ca marche, un prim dont une moitié est invisible, et l'autre visible representant la porte, et ce prim tourne donc on voir la même chose que pour l'autre sauf qu'il n'y a pas de cylindre

[Llew Iredell]

Citation :

Quelqu'un qui peut expliquer le principe dans les grandes lignes, définir "Euler", etc...?

Bon, autant le dire tout de suite : bienvenue en Enfer
Pour faire simple, le "Euler" est une mesure de rotation, comme le degré ou le radian par exemple, mais adpatée aux 3 dimensions. Mais ce qui est utilisé dans SL, ce sont les "quaternions" (vous qui lisez ceci, abandonnez tout espoir ).
Je me suis penchée sur la question à un moment et je n'ai rien compris du tout au fonctionnement des quaternions Donc, pour utiliser les rotations, je travaille par conversions successives, selon le process suivant :

- récupèration de l'angle
- conversion du quaternion en Euler
- conversion du Euler en degré (sous forme d'un vecteur <x,y,z>)
- ajout de ma modification d'angle au vecteur. Par exemple si je veux tourner de 90° sur l'axe Z, j'aurais : <x,y,z>+<0,0,90>
- conversion des degrés en euler
- conversion des euler en quaternion
- application de la nouvelle position

C'est lourd, mais après 2 semaines de mon temps libre passé à essayer de jongler directement avec les quaternions, j'ai tout envoyé bouler et je me suis faite une petite bibliothèque de fonctions sur le principe ennoncé ci dessus. C'est pas franchement optimisé mais au moins, ça marche !

Pour le côté technique, tu trouveras toutes les fonctions LSL nécessaires ici :
http://www.lslwiki.com/
et plus précisement dans le chapitre dédié aux rotations:
http://www.lslwiki.com/lslwiki/wakka.php?wakka=rotation

[Riona]

/me lis attentivement l'explication de Llew Iredell..... ....
/me retourne draguée et même au galop!

bon courage DelK ^^

*cheek*

[Lhoreena]

Ce que tu appels Euler sont en fait les angles d'Euler : ça correspond à la façon la plus simple de décrire les 3 rotations principales de l'espace.
C'est celle que tu utilises lorsque tu paramètres un prim sous SL tout bêtement : Rotation autour d'un axe X, d'un axe Y et d'un axe Z.

Ici une animation en flash qui permet de visualiser tout ça.

La description des rotations par les angles d'Euler est simple (enfin quoi que...) à comprendre, le soucis principal est que c'est pas très adapté pour faire tourner un objet.

Ce qui suis est un résumé de résumé d'interprétation de ce qui est raconté là. Donc je peux faire quelques erreurs (;

Si tu veux faire tourner un vecteur d'un angle donné tu définis en somme la position de départ et celle d'arriver. Le problème principal est qu'il y a deux chemins possibles pour faire ce trajet : imagine deux points sur un cercle : pour aller d'un point à un autre on peut suivre indifféremment le trajet représenté par l'un des deux arcs.
Un des avantages des quaternions est d'être capable de "dire" quel chemin tu vas emprunter, ce qui est plutôt pratique lorsque l'on veut animer des objets.

Comment c'est foutu un quaternion ?

C'est un couple constitué d'un Réel "a" et d'un Vecteur "V" de composantes Vx, Vy et Vz on pourra le noter (a, V) ou bien (a, Vx, Vy, Vz). Attention sous SL si mes souvenirs sont bons le quaternion est noté à dans l'autre sens : (V, a) ou bien (Vx, Vy, Vz, a).

Je passe les détails mais : ce quaternion peut être noté sous la forme suivante : (je garde l'écriture SLienne).

Q = (q.cos(Phi) U, q.sin(Phi) )

avec : q un réel, Phi un angle, et U un vecteur unitaire (dont la norme est égale à 1 : (Ux)²+(Uy)²+(Uz)²=1 colinéaire à V)

Ces deux composantes du quaternion sont respectivement le produit vectoriel et le produit scalaire de deux vecteurs V1 et V2 orthogonaux à V faisant un angle Phi.

Autrement dit : ce quaternion peut être apparenté à une rotation du vecteur V1 autour du vecteur U d'un angle Phi ce qui donne le vecteur V2.

Alors comment qu'on s'en sert ?

Et bien : Soit un vecteur V1 que je veux faire tourner d'un angle de 2.Phi autour d'un vecteur unitaire U. Le résultat de cette rotation sera appelé V2.

(pour conserver cette notion de trajet parcouru on va passer par deux quaternions conjugués d'où l'utilisation du demi angle voulu).

(un vecteur peut être considéré comme un quaternion dont le scalaire est nul)

On aura :

(V2, 0) = (cos(Phi) U, sin(Phi)) . (V1,0) . (cos(Phi) U, -sin(Phi))

C'est ce quaternion (cos(Phi) U, sin(Phi)) qui est utilisé dans SL pour représenter la variable Rotation.

Pour fabriquer cette variable il faut tout simplement connaître :

- Un vecteur unitaire directeur de l'axe de rotation : U = (Ux, Uy, Uz) tel que (Ux)²+(Uy)²+(Uz)²=1

- L'angle de rotation voulu Alpha dont on prendra la moitié Phi : Alpha = 2.Phi

La variable rotation sera alors :

(Ux.cos(Phi), Uy.cos(Phi), Uz.cos(Phi), sin(Phi)

Voila pour l'histoire des rotations et des quaternions. J'éspère ne pas avoir raconté trop de conneries.

Un bout d'exemple : Un script qui permet de faire tourner un objet de 90° autour de l'axe Z lorsqu'on clique dessus. (avec des PB lorsque l'on arrive au tour complet mais bon... c(; )

Citation :

float angleR;

default
{
state_entry()
{
angleR = 0;
}

touch_start(integer total_number)
{
angleR = angleR + PI_BY_TWO;
llSetRot(<0.0, 0.0, llCos(angleR), llSin(angleR)>);
}
}

la même chose avec un morceau de script issu du wiki :

Citation :

float angle;

default
{
state_entry()
{
angle = 0;
}

touch_start(integer total_number)
{
angle = angle + 90;
vector eul = <0,0,angle>; //45 degrees around the z-axis, in Euler form
eul *= DEG_TO_RAD; //convert to radians
rotation quat = llEuler2Rot(eul); //convert to quaternion
llSetRot(quat); //rotate the object
}
}