Difference between revisions of "Rotation/fr"

From Second Life Wiki
Jump to navigation Jump to search
m (Localized the header)
 
(15 intermediate revisions by 2 users not shown)
Line 1: Line 1:
{{Multi-lang}}
{{Multi-lang}}
{{LSL Header}}{{RightToc}}
{{LSL Header/fr}}
 
{{RightToc}}
************************** PAGE EN COURS DE TRADUCTION PAR SAMIA **********************************************


=Rotations=
=Rotations=
Le type LSL '''rotation''' est utilisé pour représenter une orientation en 3D (nous nous efforçons d'écrire le nom des types en '''gras''').
Le type LSL '''rotation''' est utilisé pour représenter une orientation en 3D (nous nous efforçons d'écrire le nom des types en '''gras''').
Une orientation, ou angle en 3D, est représentée par un objet mathématique appelé un {{LSLG|quaternion}}.  Considérons les quaternions comme un ensemble de 4 nombres, dont trois représentent la direction à laquelle l'objet fait face et la quatrième son pivotage vers la droite ou vers la gauche autour de cette direction. Le principal intérêt d'utiliser les quaternions est qu'ils ne sont pas sujets à la perte de degré de liberté ([http://fr.wikipedia.org/wiki/Gimbal_Lock gimbal lock]).  
Une orientation, ou angle en 3D, est représentée par un objet mathématique appelé un {{LSLG|quaternion/fr|quaternion}}.  Considérons les quaternions comme un ensemble de 4 nombres, dont trois représentent la direction à laquelle l'objet fait face et la quatrième son pivotage vers la droite ou vers la gauche autour de cette direction. Le principal intérêt d'utiliser les quaternions est qu'ils ne sont pas sujets à la perte de degré de liberté ([http://fr.wikipedia.org/wiki/Gimbal_Lock gimbal lock]).  
Pour le fonctionnement interne complexe des mathématiques des quaternions, voir {{LSLG|quaternion}}.  
Pour le fonctionnement interne complexe des mathématiques des quaternions, voir {{LSLG|quaternion/fr|quaternion}}.  
Pour une liste de fonctions ou d'évènements liés aux rotations, voir {{LSLG|Rotation Synopsis}}.
Pour une liste de fonctions ou d'évènements liés aux rotations, voir {{LSLG|Rotation Synopsis|résumé des rotations}}.
Il y a aussi des informations sur la façon de faire tourner des textures sur la page {{LSLG|texture}}s.
Il y a aussi des informations sur la façon de faire tourner des textures sur la page consacrée aux {{LSLG|texture/fr|texture}}s.


==Autres representations==
==Autres représentations==
Une autre façon de représenter une rotation est d'utiliser 3 nombres, <X, Y, Z>, qui représentent de combien (en [[radians]]) l'objet tourne autour de trois axes. C'est par exemple utilisé dans la fenêtre de modification et est généralement facilement visualisé par les gens. Notez que ces trois nombres sont de type '''vector''' et non de type '''rotation''', bien que cela puisse représenter la même information. On appelle cela les rotations d'Euler.
Une autre façon de représenter une rotation est d'utiliser 3 nombres, <X, Y, Z>, qui représentent de combien (en [[radians]]) l'objet tourne autour de trois axes. C'est par exemple utilisé dans la fenêtre de modification et est généralement facilement visualisé par les gens. Notez que ces trois nombres sont de type '''vector''' et non de type '''rotation''', bien que cela puisse représenter la même information. On appelle cela les rotations d'Euler.
   
   
Line 29: Line 28:


==Dans le monde ou localement==
==Dans le monde ou localement==
Il est important de différencier les '''rotation'''s relatives au monde et la '''rotation''' relative to the local object itself. In the editor, you can switch back and forth from one to the other. In a script, you must convert from one to the other to get the desired behavior.
Il est important de différencier les '''rotation'''s relatives au monde et la '''rotation''' relative à l'objet lui-même.
Dans la fenetre de modifications, vous pouvez passer de l'une à l'autre. Dans un script, il faut convertir l'une en l'autre pour obtenir le comportement souhaité.


To get the '''rotation''' in a script of an unlinked prim, use:
Pour obtenir la '''rotation''' d'une prim non liée depuis un script, utiliser :


<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation myRot ||= {{LSLG|llGetRot}}();||// load the world rotation into myRot
|rotation maRot ||= {{LSLG|llGetRot}}();||// charge la rotation par rapport au monde dans maRot
|}
|}
</div></div>
</div></div>


== Combining Rotations ==
== Rotations combinées ==


To combine '''rotations''', you use the '''multiply''' and '''divide''' operators. Don't try to use addition or subtraction operators on '''rotations''', as they will not do what you expect. The '''multiply''' operation applies the rotation in the positive direction, the '''divide''' operation does a negative rotation. You can also negate a rotation directly, just negate the s component, e.g. X.s = -X.s.
Pour combiner des '''rotations''', on utilise les opérateurs '''multiplier''' et '''diviser'''.  
Ne pas utiliser les opérateurs addition ou soustraction, qui ne donneront pas le résultat attendu.
L'opération '''multiplier''' s'applique à la rotation dans le sens direct, l'opération '''diviser''' effectue une rotation en sens inverse.
Il est également possible d'obtenir une rotation inverse directement, en calculant l'opposé du composant S avec le signe - : X.s = -X.s.


Unlike other types such as {{LSLG|float}}, the order in which the operations are done,
À l'inverse d'autres types comme {{LSLG|float/fr|float}}, l'ordre dans lequel les opérations sont effectuées est important. [http://fr.wikipedia.org/wiki/Commutativité non commutative].
[http://en.wikipedia.org/wiki/Commutative non-commutative], is important.
La raison en est simple : l'ordre dans lequel on effectue des rotations est importante dans le monde réel.
The reason for this is simple: the order you do rotations in is important in RL. For example, if you had a dart with four feathers, started from rotation <0, 0, 0> with its tail on the origin, it would lie on the X axis with its point aimed in the positive X direction, its feathers along the Z and Y axes, and the axes of the dart and the axes of the world would be aligned. We're going to rotate it 45 degrees around X and 30 degrees around Y, but in different orders.
Par exemple, si vous avez une flèche avec quatre plumes, au départ à la rotation <0, 0, 0> avec sa queue comme origine, elle sera alignée sur l'axe X avec sa pointe dans la direction X positive, ses plumes seront alignées sur les axes Z et Y et les axes de la fleche seront alignés sur les axes dans le monde.
Nous allons la faire tourner de 45 degrés autour de l'axe X et de 30 degrés autour de l'axe Y, mais en changeant l'ordre.


First, after rotating 45 deg around X the dart would still be on the X axis, unmoved, just turned along its long axis, so the feathers would be at 45 deg to the axes. Then rotating 30 deg around Y would move it in the XZ plane to point down 30 deg from the X axis (remember the right hand rule for rotations means a small positive rotation around Y moves the point down). The dart winds up pointing 30 deg down, in the same vertical plane it started in, but turned around its own long axis so the feathers are no longer up and down.
D'abord, après une rotation de 45° autour de l'axe X, la flèche sera toujours alignée le long de l'axe X et n'aura pas bougé, elle aura simplement pivoté autour de son axe, donc les plumes seront à 45° des axes.
Ensuite, la faire tourner de 30° autour de l'axe Y la fera pointer de 30° vers le bas (par rapport à l'axe X - souvenez vous que la règle de la main droite fait qu'une rotation positive va vers le bas).
La flèche finit par être pointée de 30° vers le bas, sur le même plan vertical qu'au départ, mais en ayant pivoté sur elle même, ce qui fait que les plumes ne sont plus alignées vers le haut et le bas.


If you did it the other way, first rotating 30 deg in Y, the dart would rotate down in the XZ plane, but notice that it no longer is on the X axis; its X axis and the world's aren't aligned any more. Now a 45 degree rotation around the X axis would pivot the dart around its tail, the point following a 30 deg cone whose axis is along the positive world X axis, for 45 degrees up and to the right. If you were looking down the X axis, it would pivot from pointing 30 deg below the X axis, up and to the right, out of the XZ plane, to a point below the 1st quadrant in the XY plane, its feathers rotating as it went.
Si on effectue les modifications dans l'autre ordre, en commençant par une rotation de 30° sur l'axe Y, la flèche va pencher vers le bas par rapport au plan XY. Notez qu'elle n'est plus alignée par rapport à son axe X : donc, son axe X et celui du monde ne sont plus alignés l'un par rapport à l' autre. Une rotation de 45° autour de l'axe X la fera pivoter autour de sa queue, la pointe tournera de 45° vers le haut et la droite en suivant un cône de 30° dont l'axe est aligné avec l'axe positif dans le monde.  


Clearly this is a different result from the first rotation, but the order of rotation is the only thing changed.
Le résultat est clairement différent de celui de la premiere rotation, alors que seul l'ordre dans lequel les rotations ont été effectuées a changé.  


To do a constant rotation you need to define a '''rotation''' value which can be done by creating a {{LSLG|vector}} with the X, Y, Z angles in radians as components (called an Euler angle), then converting that to a '''rotation''' by using the {{LSLG|llEuler2Rot}} function. You can alternately create the native rotation directly: the real part is the cosine of half the angle of rotation, and the vector part is the normalized axis of rotation multiplied by the sine of half the angle of rotation. To go from a rotation to an Euler angle {{LSLG|vector}} use {{LSLG|llRot2Euler}}.
Pour effectuer une rotation constante, vous devez définir une valeur '''rotation''', ce qui se fait en créant un {{LSLG|vector/fr|vector}} avec comme composants les angles X, Y, Z en radians (cela s'appelle un angle d'Euler), puis en le convertissant en '''rotation''' avec la fonction {{LSLG|llEuler2Rot/fr|llEuler2Rot}}.
Vous pouvez aussi créer directement une rotation native : la partie réelle est le cosinus de la motié de l'angle de rotation et la partie vectorielle l'axe normalisé de rotation multiplié par le sinus de la moitié de l'angle de rotation.
Pour passer d'une rotation à un {{LSLG|vector/fr|vecteur}} angle d'Euler, utilisez {{LSLG|llRot2Euler}}.


'''NOTE:''' angles in LSL are in radians, not degrees, but you can easily convert by using the built-in constants [[#RAD_TO_DEG|RAD_TO_DEG]] and [[#DEG_TO_RAD|DEG_TO_RAD]]. For a 30 degree '''rotation''' around the X axis you might use:
'''NOTE:''' les angles dans LSL sont en radians, pas en degrés, mais vous pouvez facilement les convertir avec les constantes prédéfinies  [[#RAD_TO_DEG|RAD_TO_DEG]] et [[#DEG_TO_RAD|DEG_TO_RAD]].
Pour une '''rotation''' de 30 degrés autour de l'axe X par exemple :  


<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation rot30X ||= {{LSLG|llEuler2Rot}}(<30, 0,0> * DEG_TO_RAD);||// convert the degrees to radians, then convert that {{LSLG|vector}} into a rotation, rot30x
|rotation rot30X ||= {{LSLG|llEuler2Rot/fr|llEuler2Rot}}(<30, 0,0> * DEG_TO_RAD);||// convertit les degrés en radians, puis convertit ce {{LSLG|vector/fr|vecteur}} en une rotation, rot30x
|-
|-
|{{LSLG|vector}} vec30X ||= {{LSLG|llRot2Euler}}(rot30X );||// convert the rotation back to a {{LSLG|vector}} (the values will be in radians)
|{{LSLG|vector/fr|vector}} vec30X ||= {{LSLG|llRot2Euler/fr|llRot2Euler}}(rot30X );||// retransforme la rotation en un {{LSLG|vector/fr|vecteur}} (avec les valeurs en radians)
|}
|}
</div></div>
</div></div>


== Local vs Global rotations ==
== Rotations locales ou globales ==


'''Local''' rotations are ones done around the axes embedded in the object itself forward/back, left/right, up/down, irrespective of how the object is rotated in the world. '''Global''' rotations are ones done around the world axes, North/South, East/West, Higher/Lower. You can see the difference by rotating a prim, then edit it and change the axes settings between local and global, notice how the colored axes arrows change.
Les rotations '''locales''' sont effectuées autour des axes de l'objet lui-même, dans les directions avant/arriere, droite/gauche et bas/haut, quelle que soit l'orientation de l'objet dans le monde qui l'entoure. Les rotations '''globales''' sont effectuées autour des axes du monde, Nord/Sud, Est/Ouest, plus haut/plus bas.
Vous pouvez voir la différence en faisant tourner une prim, puis en la modifiant et en changeant les réglages d'axes entre local et global : regardez comment les flèches de couleur changent.


In LSL, the difference between doing a '''local''' or '''global''' rotation is the order the '''rotations''' are evaluated in the statement.
Dans LSL, la différence entre une rotation '''locale''' ou '''globale''' réside dans l'ordre dans selon lequel les '''rotations''' seront évaluées dans l'instruction.


This does a '''local''' rotation by putting the constant 30 degree '''rotation''' to the left of the object's '''rotation'''. It is like the first operation in the first example above, just twisting the dart around its own long axis.
Ce script effectue une rotation '''locale''' en plaçant la '''rotation''' constante de 30° à gauche de la '''rotation''' de l'objet. C'est comme la première opération effectuée dans l'exemple précédent, cela fait pivoter la flèche autour de son axe longitudinal.


<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation localRot = ||rot30X * myRot;||// do a local rotation by multiplying a constant rotation by a world rotation
|rotation rotLocale = ||rot30X * maRot;||// effectue une rotation locale en multipliant une rotation constante par une rotation dans le monde.
|}
|}
</div></div>
</div></div>


To do a '''global''' rotation, use the same '''rotation''' values, but in the opposite order. This is like the second operation in the second example, the dart rotating up and to the right around the world X axis.
Pour effectuer une rotation '''globale''', utiliser les mêmes valeurs '''rotation''', mais dans l'ordre opposé. Cela correspond à la seconde rotation du second exemple, avec la flèche qui pivote vers le haut et la droite autour de l'axe X du monde.


<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation globalRot || = myRot * rot30X;||// do a global rotation by multiplying a world rotation by a constant rotation
|rotation rotGlobale || = maRot * rot30X;||// effectue une rotation globale en multipliant une rotation dans le monde par une rotation constante.
|}
|}
</div></div>
</div></div>


== Another way to think about combining rotations ==
== Une autre façon de voir les rotations combinées ==


You may want to think about this '''local''' vs '''global''' difference by considering that '''rotations''' are done in evaluation order, that is left to right except for parenthesized expressions.
Regardez cette différence entre '''locale''' et '''globale''' en considérant que les '''rotations''' sont effectuées dans l'ordre de traitement, ce qui veut dire de gauche à droite sauf pour les expressions entre parenthèses.


In the localRot case, what happened was that starting from <0, 0, 0>, the rot30X was done first, rotating the prim around the world X axis, but since when it's unrotated, the local and global axes are identical it has the effect of doing the rotation around the object's local X axis. Then the second '''rotation''' myRot was done which rotated the prim to its original rotation, but now with the additional X axis rotation baked in. What this looks like is that the prim rotated in place around its own X axis, a '''local''' rotation.
Dans le cas du rotLocale, ce qui se passe est qu'en partant de <0, 0, 0>, la rot30X est effectuée en premier et fait tourner la prim autour de l'axe X du monde. Dans la mesure où la prim n'a pas encore bougé, les axes local et global sont identiques, donc le résultat est de faire tourner la prim autour de son propre axe local X. Ensuite, la deuxième '''rotation''' maRot est exécutée, ce qui fait pivoter la prim vers sa position d'origine, mais en intégrant la rotation X précédente. Le résultat est que la prim tourne sur place autour de son propre axe X, ce qui est une rotation '''locale'''.


In the globalRot case, again starting from <0, 0, 0>, first the object is rotated to its original rotation, but the object's axes and the world's axes are no longer aligned! So, now the second '''rotation''' rot30x does exactly what it did in the local case, rotates the object 30 degrees around the world X axis, but the effect is to rotate the object through a cone around the world X axis since the object's X axis and the world's X axis aren't the same this time. What this looks like is that the prim pivoted 30 degrees around the world X axis, hence a '''global''' rotation.
Dans le cas du globalRot, toujours en partant de <0, 0, 0>, l'objet pivote d'abord vers sa position d'origine, mais les axes de l'objet et du monde ne sont plus alignés.  Donc la deuxième '''rotation''' rot30x fait exactement la meme chose que dans le cas local, c'est a dire qu'elle tourne l'objet de 30° autour de l'axe X du monde, mais la conséquence est que l'objet pivote suivant un cône aligné sur l'axe X du monde, puisque les axes X du monde et de l'objet ne sont plus alignés dans ce cas. Le résultat est que la prim tourne de 30° autour de l'axe X du monde, ce qui est une rotation '''globale'''.


'''Division''' of '''rotations''' has the effect of doing the rotation in the opposite direction, multiplying by a 330 degree '''rotation''' is the same as dividing by a 30 degree '''rotation'''.
La '''division''' de '''rotations''' a pour effet d'effectuer la rotation dans le sens opposé : multiplier une '''rotation''' par 330 degrés revient au même que diviser par une '''rotation''' de 30 degrés.


==Using Rotations ==
==Utilisation des rotations ==


You can access the individual components of a '''rotation''' '''R''' by '''R.x, R.y, R.z, & R.s''' ('''not''' R.w).  The scalar part R.s is the cosine of half the angle of rotation.  The vector part (R.x,R.y,R.z) is the product of the normalized axis of rotation and the sine of half the angle of rotation. You can generate an inverse '''rotation''' by negating the x,y,z members (or by making the s value negative). As an aside, you can also use a '''rotation''' just as a repository of {{LSLG|float}} values, each '''rotation''' stores four of them and a {{LSLG|list}} consisting of '''rotation''' is more efficient than a {{LSLG|list}} consisting of {{LSLG|float}}s, but there is overhead in unpacking them.
On peut accéder à chacune des composantes d'une '''rotation''' '''R''' au moyen de '''R.x, R.y, R.z et R.s''' ('''pas''' R.w).  la partie scalaire R.s est le cosinus de la moitié de l'angle de rotation. La partie vectorielle (R.x, R.y, R.z) est le produit du vecteur unitaire dirigeant l'axe de rotation par le sinus de la moitié de l'angle de rotation. On peut obtenir une '''rotation''' inverse en utilisant des nombres opposés pour x, y et z (ou en utilisant une valeur s opposée).
De plus, vous pouvez aussi utiliser une '''rotation''' en tant que conteneur pour des valeurs {{LSLG|float/fr|float}}, chaque '''rotation''' en contenant quatre, une {{LSLG|list/fr|liste}} composée de '''rotations''' étant plus efficace qu'une {{LSLG|list}} composée de {{LSLG|float/fr|float}}s, mais cela implique de les déballer au préalable.


<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation rot30X ||= {{LSLG|llEuler2Rot}}(<30, 0,0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// Create a rotation constant
|rotation rot30X ||= {{LSLG|llEuler2Rot/fr|llEuler2Rot}}(<30, 0,0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// Crée une rotation constante
|-
|-
|rotation rotCopy ||= rot30X;||// Just copy it into rotCopy, it copies all 4 float components
|rotation rotCopiee ||= rot30X;||// Simplement la copier dans rotCopiee, cela copie les 4 composantes float
|-
|-
|float X ||= rotCopy.x;||// Get out the individual components of the rotation
|float X ||= rotCopiee.x;||// Extrait chacune des composantes d'une rotation
|-
|-
|float Y ||= rotCopy.y;||
|float Y ||= rotCopiee.y;||
|-
|-
|float Z ||= rotCopy.z;||
|float Z ||= rotCopiee.z;||
|-
|-
|float S ||= rotCopy.s;||
|float S ||= rotCopiee.s;||
|-
|-
|rotation anotherCopy ||= <X, Y, Z, S>;||// Make another rotation out of the components
|rotation uneAutreCopie ||= <X, Y, Z, S>;||// Crée une nouvelle rotation à partir des composantes
|}
|}
</div></div>
</div></div>




There is a built in constant for a zero '''rotation''' [[#ZERO_ROTATION|ZERO_ROTATION]] which you can use directly or, if you need to invert a '''rotation R''', divide [[#ZERO_ROTATION|ZERO_ROTATION]] by '''R'''. As a reminder from above, this works by first rotating to the zero position, then because it is a divide, rotating in the opposite sense to the original '''rotation''', thereby doing the inverse rotation.
Il existe une constante prédéfinie pour la '''rotation''' nulle [[#ZERO_ROTATION|ZERO_ROTATION]] qui peut être utilisée directement. Si vous avez besoin d'inverser une '''rotation R''', divisez [[#ZERO_ROTATION|ZERO_ROTATION]] par '''R'''. Rappel de ce qui est ci-dessus, cela fonctionne en effectuant d'abord une rotation à la position zéro, puis (parce que c'est une division) en tournant dans le sens inverse de la '''rotation''' d'origine, ce qui revient donc à une rotation inversée.
<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation rot330X ||= <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>;||// invert a rotation - NOTE the s component isn't negated
|rotation rot330X ||= <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>;||// Inverse une rotation - NOTE la composante s n'est pas négative
|-
|-
|rotation another330X ||= [[#ZERO_ROTATION|ZERO_ROTATION]] / rot30X;||// invert a rotation by  division, same result as rot330X
|rotation uneAutre330X ||= [[#ZERO_ROTATION|ZERO_ROTATION]] / rot30X;||// Inverse la rotation avec une division, même résultat que rot330X
|-
|-
|rotation yetanother330X ||= <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>;||// not literally the same but works the same.
|rotation encoreUneAutre330X ||= <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>;||// pas exactement la même chose, mais revient au même.
|}
|}
</div></div>
</div></div>


==Single or Root Prims vs Linked Prims vs Attachments ==
== Prims uniques ou racine / prims liées et attachements ==


The reason for talking about single or linked prim rotations is that for things like doors on vehicles, the desired motion is to move the door relative to the vehicle, no matter what the rotation of the overall vehicle is. While possible to do this with global rotations, it would quickly grow tedious.
Ceci est important pour des objets tels que les portes sur un véhicule : le mouvement de la porte doit s'effectuer par rapport au véhicule, quelle que soit la façon dont celui-ci est tourné. S'il est possible de le faire avec des rotations globales, cela ne tardera pas à être pénible.
There are generally three coordinate systems a prim can be in: all alone, part of a {{LSLG|linkset}}, or part of an {{LSLG|attachment}}. When a prim is alone, i.e., not part of a {{LSLG|linkset}}, it acts like a root prim; when it is part of an {{LSLG|attachment}}, it acts differently and is a bit broken.
Une prim peut faire partie de 3 systèmes de coordonnées : tout seul, partie d'un {{LSLG|linkset/fr|ensemble lié}} ou partie d'un {{LSLG|attachment/fr|attachement}}.
Quand la prim est seule, c'est-à-dire qu'elle ne fait pas partie d'un {{LSLG|linkset/fr|ensemble lié}}, elle se comporte comme une prim racine; quand elle fait partie d'un {{LSLG|attachment/fr|attachement}}, elle se comporte différemment, et de façon moins cohérente.


{{LSLRotGetSet}}
{{LSLRotGetSet/fr}}


==Rotating Vectors ==
==Rotation de vecteurs ==


In LSL, rotating a {{LSLG|vector}} is very useful if you want to move an object in an arc or circle when the center of rotation isn't the center of the object.
Dans LSL, faire pivoter un {{LSLG|vector/fr|vecteur}} est très utile quand vous voulez faire bouger un objet suivant un arc de cercle, mais que le centre de la rotation n'est pas le centre de l'objet.


This sounds very complex, but there is much less here than meets the eye. Remember from the above discussion of rotating the [[#Combining Rotations|dart]], and replace the physical dart with a {{LSLG|vector}} whose origin is the tail of the dart, and whose components in X, Y, and Z describe the position of the tip of the dart. Rotating the dart around its tail moves the tip of the dart through and arc whose center of rotation is the tail of the dart. In exactly the same way, rotating a {{LSLG|vector}} which represents an offset from the center of a prim rotates the prim through the same arc. What this looks like is the object rotates around a position offset by the {{LSLG|vector}} from the center of the prim.
Ca peut sembler très compliqué, mais c'est beaucoup plus simple qu'il n'y paraît.  
Rappelez vous de la partie ci dessus sur la rotation de [[#Combining Rotations|flèche]], et remplacez la flèche par un {{LSLG|vector/fr|vecteur}} dont l'origine est la queue de la flèche et dont les composants  X, Y et Z indiquent la position de la pointe de la flèche. Faire tourner la flèche autour de sa queue fait bouger sa pointe suivant un arc dont le centre est la queue de la flèche. De la même façon, faire tourner un {{LSLG|vector/fr|vecteur}} qui représente un décalage par rapport au centre de la prim la fait pivoter suivant le même arc.
L'objet pivote autour d'une position qui est décalée par rapport au centre de la prim par le {{LSLG|vector/fr|vector}}.
<div id="box"><div style="padding: 0.5em">
<div id="box"><div style="padding: 0.5em">
{| cellpadding=0 cellspacing=0
{| cellpadding=0 cellspacing=0
|-
|-
|rotation rot30X ||= {{LSLG|llEuler2Rot}}(<30, 0,0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// create a rotation constant, 30 degrees around the X axis
|rotation rot30X ||= {{LSLG|llEuler2Rot/fr|llEuler2Rot}}(<30, 0,0> * [[#DEG_TO_RAD|DEG_TO_RAD]] );||// crée une rotation constante, 30 degrés autour de l'axe X
|-
|-
|vector offset ||= <0, 1, 0>;||// create an offset one meter in the global positive Y direction
|vector decalage ||= <0, 1, 0>;||// décale d'un mètre dans la direction Y positive
|-
|-
|vector rotatedOffset || = offset * rot30X;||// rotate the offset to get the motion caused by the rotations
|vector decalageTourne || = decalage * rot30X;||// fait tourner le vecteur décalage pour obtenir le mouvement donné par la rotation
|-
|-
|vector newPos || = {{LSLG|llGetPos}}() + rotatedOffset;||// move the prim position by the rotated offset amount
|vector nouvellePos || = {{LSLG|llGetPos/fr|llGetPos}}() + decalageTourne;||// déplace la position de la prim en fonction du décalage tourné
|}
|}
</div></div>
</div></div>


'''Nota Bene:''' Doing this is a move, so don't forget about issues of moving a prim off world, below ground, more than 10 meters etc.
'''Nota Bene:''' Ceci est un mouvement, donc prenez garde aux problèmes qui se posent lorsqu'un objet est bougé hors du monde, sous le sol, de plus de 10 mètres, etc...


== Constants ==
== Constantes ==
=== [[ZERO_ROTATION]] ===
=== [[ZERO_ROTATION/fr|ZERO_ROTATION]] ===
ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;<br/>
ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;<br/>
A rotation constant representing a Euler angle of <0.0, 0.0, 0.0>.
Une constante de rotation correspondant à un angle d'Euler de <0.0, 0.0, 0.0>.


=== [[DEG_TO_RAD]] ===
=== [[DEG_TO_RAD/fr|DEG_TO_RAD]] ===
DEG_TO_RAD = 0.01745329238f;<br/>
DEG_TO_RAD = 0.01745329238f;<br/>
A float constant that when multiplied by an angle in degrees gives the angle in radians.
Une constante float qui donne l'angle en radians quand on multiplie l'angle en degrés par elle.


=== [[RAD_TO_DEG]] ===
=== [[RAD_TO_DEG/fr|RAD_TO_DEG]] ===
RAD_TO_DEG = 57.29578f;<br/>
RAD_TO_DEG = 57.29578f;<br/>
A float constant when multiplied by an angle in radians gives the angle in degrees.
Une constante float qui donne l'angle en degrés quand on multiplie l'angle en radians par elle.




[[Category:LSL_Types/fr|Rotation]][[Category:LSL_Math/fr]][[Category:LSL_Math/3D/fr]][[Category:LSL_Constants/fr]]
[[Category:LSL_Types/fr|Rotation]][[Category:LSL_Math/fr]][[Category:LSL_Math/3D/fr]][[Category:LSL_Constants/fr]]

Latest revision as of 01:49, 30 December 2007

Rotations

Le type LSL rotation est utilisé pour représenter une orientation en 3D (nous nous efforçons d'écrire le nom des types en gras). Une orientation, ou angle en 3D, est représentée par un objet mathématique appelé un quaternion. Considérons les quaternions comme un ensemble de 4 nombres, dont trois représentent la direction à laquelle l'objet fait face et la quatrième son pivotage vers la droite ou vers la gauche autour de cette direction. Le principal intérêt d'utiliser les quaternions est qu'ils ne sont pas sujets à la perte de degré de liberté (gimbal lock). Pour le fonctionnement interne complexe des mathématiques des quaternions, voir quaternion. Pour une liste de fonctions ou d'évènements liés aux rotations, voir résumé des rotations. Il y a aussi des informations sur la façon de faire tourner des textures sur la page consacrée aux textures.

Autres représentations

Une autre façon de représenter une rotation est d'utiliser 3 nombres, <X, Y, Z>, qui représentent de combien (en radians) l'objet tourne autour de trois axes. C'est par exemple utilisé dans la fenêtre de modification et est généralement facilement visualisé par les gens. Notez que ces trois nombres sont de type vector et non de type rotation, bien que cela puisse représenter la même information. On appelle cela les rotations d'Euler.

Une troisième façon de faire est d'utiliser trois vecteurs, qui vont indiquer vers où sont orientés l'avant, le dessus et le coté gauche. En réalité, il n'y a besoin que de deux de ces vecteurs, le troisième découlant des deux premiers.

Il y a de bonne raisons de préférer la version à quatre nombres, la rotation, bien qu'elle soit plus compliquée à s'approprier pour des débutants. Il existe des fonctions qui permettent de convertir facilement d'une représentation à une autre.

La règle de la main droite

Dans LSL, toutes les rotations sont effectuées suivant la règle de la main droite. Avec votre main droite, pointez l'index vers la direction de l'axe X positif, le majeur à angle droit de l'index pointera alors en direction de l'axe Y positif, et le pouce, à angle droit des deux autres, pointera vers l'axe Z positif. Lorsque vous modifiez un objet, les trois flèches de couleur pointent vers le coté positif de chacun des axes (X rouge, Y vert, Z bleu).

Règle de la main droite

Gardez votre main en position, c'est utile pour autre chose : trouver de quel côté est l'axe positif. Fermez le poing et sortez le pouce en direction du coté positif de l'axe qui vous intéresse. Vos autres doigts sont repliés dans le sens des axes positifs. Les rotations autour des axes X, Y et Z sont géréralement appelées roulis, tangage et lacet, en particulier lorsqu'il est question de véhicules.

Roulis, tangage et lacet

Dans le monde ou localement

Il est important de différencier les rotations relatives au monde et la rotation relative à l'objet lui-même. Dans la fenetre de modifications, vous pouvez passer de l'une à l'autre. Dans un script, il faut convertir l'une en l'autre pour obtenir le comportement souhaité.

Pour obtenir la rotation d'une prim non liée depuis un script, utiliser :

rotation maRot = llGetRot(); // charge la rotation par rapport au monde dans maRot

Rotations combinées

Pour combiner des rotations, on utilise les opérateurs multiplier et diviser. Ne pas utiliser les opérateurs addition ou soustraction, qui ne donneront pas le résultat attendu. L'opération multiplier s'applique à la rotation dans le sens direct, l'opération diviser effectue une rotation en sens inverse. Il est également possible d'obtenir une rotation inverse directement, en calculant l'opposé du composant S avec le signe - : X.s = -X.s.

À l'inverse d'autres types comme float, l'ordre dans lequel les opérations sont effectuées est important. non commutative. La raison en est simple : l'ordre dans lequel on effectue des rotations est importante dans le monde réel. Par exemple, si vous avez une flèche avec quatre plumes, au départ à la rotation <0, 0, 0> avec sa queue comme origine, elle sera alignée sur l'axe X avec sa pointe dans la direction X positive, ses plumes seront alignées sur les axes Z et Y et les axes de la fleche seront alignés sur les axes dans le monde. Nous allons la faire tourner de 45 degrés autour de l'axe X et de 30 degrés autour de l'axe Y, mais en changeant l'ordre.

D'abord, après une rotation de 45° autour de l'axe X, la flèche sera toujours alignée le long de l'axe X et n'aura pas bougé, elle aura simplement pivoté autour de son axe, donc les plumes seront à 45° des axes. Ensuite, la faire tourner de 30° autour de l'axe Y la fera pointer de 30° vers le bas (par rapport à l'axe X - souvenez vous que la règle de la main droite fait qu'une rotation positive va vers le bas). La flèche finit par être pointée de 30° vers le bas, sur le même plan vertical qu'au départ, mais en ayant pivoté sur elle même, ce qui fait que les plumes ne sont plus alignées vers le haut et le bas.

Si on effectue les modifications dans l'autre ordre, en commençant par une rotation de 30° sur l'axe Y, la flèche va pencher vers le bas par rapport au plan XY. Notez qu'elle n'est plus alignée par rapport à son axe X : donc, son axe X et celui du monde ne sont plus alignés l'un par rapport à l' autre. Une rotation de 45° autour de l'axe X la fera pivoter autour de sa queue, la pointe tournera de 45° vers le haut et la droite en suivant un cône de 30° dont l'axe est aligné avec l'axe positif dans le monde.

Le résultat est clairement différent de celui de la premiere rotation, alors que seul l'ordre dans lequel les rotations ont été effectuées a changé.

Pour effectuer une rotation constante, vous devez définir une valeur rotation, ce qui se fait en créant un vector avec comme composants les angles X, Y, Z en radians (cela s'appelle un angle d'Euler), puis en le convertissant en rotation avec la fonction llEuler2Rot. Vous pouvez aussi créer directement une rotation native : la partie réelle est le cosinus de la motié de l'angle de rotation et la partie vectorielle l'axe normalisé de rotation multiplié par le sinus de la moitié de l'angle de rotation. Pour passer d'une rotation à un vecteur angle d'Euler, utilisez llRot2Euler.

NOTE: les angles dans LSL sont en radians, pas en degrés, mais vous pouvez facilement les convertir avec les constantes prédéfinies RAD_TO_DEG et DEG_TO_RAD. Pour une rotation de 30 degrés autour de l'axe X par exemple :

rotation rot30X = llEuler2Rot(<30, 0,0> * DEG_TO_RAD); // convertit les degrés en radians, puis convertit ce vecteur en une rotation, rot30x
vector vec30X = llRot2Euler(rot30X ); // retransforme la rotation en un vecteur (avec les valeurs en radians)

Rotations locales ou globales

Les rotations locales sont effectuées autour des axes de l'objet lui-même, dans les directions avant/arriere, droite/gauche et bas/haut, quelle que soit l'orientation de l'objet dans le monde qui l'entoure. Les rotations globales sont effectuées autour des axes du monde, Nord/Sud, Est/Ouest, plus haut/plus bas. Vous pouvez voir la différence en faisant tourner une prim, puis en la modifiant et en changeant les réglages d'axes entre local et global : regardez comment les flèches de couleur changent.

Dans LSL, la différence entre une rotation locale ou globale réside dans l'ordre dans selon lequel les rotations seront évaluées dans l'instruction.

Ce script effectue une rotation locale en plaçant la rotation constante de 30° à gauche de la rotation de l'objet. C'est comme la première opération effectuée dans l'exemple précédent, cela fait pivoter la flèche autour de son axe longitudinal.

rotation rotLocale = rot30X * maRot; // effectue une rotation locale en multipliant une rotation constante par une rotation dans le monde.

Pour effectuer une rotation globale, utiliser les mêmes valeurs rotation, mais dans l'ordre opposé. Cela correspond à la seconde rotation du second exemple, avec la flèche qui pivote vers le haut et la droite autour de l'axe X du monde.

rotation rotGlobale = maRot * rot30X; // effectue une rotation globale en multipliant une rotation dans le monde par une rotation constante.

Une autre façon de voir les rotations combinées

Regardez cette différence entre locale et globale en considérant que les rotations sont effectuées dans l'ordre de traitement, ce qui veut dire de gauche à droite sauf pour les expressions entre parenthèses.

Dans le cas du rotLocale, ce qui se passe est qu'en partant de <0, 0, 0>, la rot30X est effectuée en premier et fait tourner la prim autour de l'axe X du monde. Dans la mesure où la prim n'a pas encore bougé, les axes local et global sont identiques, donc le résultat est de faire tourner la prim autour de son propre axe local X. Ensuite, la deuxième rotation maRot est exécutée, ce qui fait pivoter la prim vers sa position d'origine, mais en intégrant la rotation X précédente. Le résultat est que la prim tourne sur place autour de son propre axe X, ce qui est une rotation locale.

Dans le cas du globalRot, toujours en partant de <0, 0, 0>, l'objet pivote d'abord vers sa position d'origine, mais les axes de l'objet et du monde ne sont plus alignés. Donc la deuxième rotation rot30x fait exactement la meme chose que dans le cas local, c'est a dire qu'elle tourne l'objet de 30° autour de l'axe X du monde, mais la conséquence est que l'objet pivote suivant un cône aligné sur l'axe X du monde, puisque les axes X du monde et de l'objet ne sont plus alignés dans ce cas. Le résultat est que la prim tourne de 30° autour de l'axe X du monde, ce qui est une rotation globale.

La division de rotations a pour effet d'effectuer la rotation dans le sens opposé : multiplier une rotation par 330 degrés revient au même que diviser par une rotation de 30 degrés.

Utilisation des rotations

On peut accéder à chacune des composantes d'une rotation R au moyen de R.x, R.y, R.z et R.s (pas R.w). la partie scalaire R.s est le cosinus de la moitié de l'angle de rotation. La partie vectorielle (R.x, R.y, R.z) est le produit du vecteur unitaire dirigeant l'axe de rotation par le sinus de la moitié de l'angle de rotation. On peut obtenir une rotation inverse en utilisant des nombres opposés pour x, y et z (ou en utilisant une valeur s opposée). De plus, vous pouvez aussi utiliser une rotation en tant que conteneur pour des valeurs float, chaque rotation en contenant quatre, une liste composée de rotations étant plus efficace qu'une list composée de floats, mais cela implique de les déballer au préalable.

rotation rot30X = llEuler2Rot(<30, 0,0> * DEG_TO_RAD ); // Crée une rotation constante
rotation rotCopiee = rot30X; // Simplement la copier dans rotCopiee, cela copie les 4 composantes float
float X = rotCopiee.x; // Extrait chacune des composantes d'une rotation
float Y = rotCopiee.y;
float Z = rotCopiee.z;
float S = rotCopiee.s;
rotation uneAutreCopie = <X, Y, Z, S>; // Crée une nouvelle rotation à partir des composantes


Il existe une constante prédéfinie pour la rotation nulle ZERO_ROTATION qui peut être utilisée directement. Si vous avez besoin d'inverser une rotation R, divisez ZERO_ROTATION par R. Rappel de ce qui est ci-dessus, cela fonctionne en effectuant d'abord une rotation à la position zéro, puis (parce que c'est une division) en tournant dans le sens inverse de la rotation d'origine, ce qui revient donc à une rotation inversée.

rotation rot330X = <-rot30X.x, -rot30X.y, -rot30X.z, rot30X.s>; // Inverse une rotation - NOTE la composante s n'est pas négative
rotation uneAutre330X = ZERO_ROTATION / rot30X; // Inverse la rotation avec une division, même résultat que rot330X
rotation encoreUneAutre330X = <rot30X.x, rot30X.y, rot30X.z, -rot30X.s>; // pas exactement la même chose, mais revient au même.

Prims uniques ou racine / prims liées et attachements

Ceci est important pour des objets tels que les portes sur un véhicule : le mouvement de la porte doit s'effectuer par rapport au véhicule, quelle que soit la façon dont celui-ci est tourné. S'il est possible de le faire avec des rotations globales, cela ne tardera pas à être pénible. Une prim peut faire partie de 3 systèmes de coordonnées : tout seul, partie d'un ensemble lié ou partie d'un attachement. Quand la prim est seule, c'est-à-dire qu'elle ne fait pas partie d'un ensemble lié, elle se comporte comme une prim racine; quand elle fait partie d'un attachement, elle se comporte différemment, et de façon moins cohérente.

Obtenir ou régler les rotations de prims
Fonction Isolée ou racine Membre d'un ensemble lié Attachement Membre d'un ensemble lié attaché
llGetRot
llGetPrimitiveParams 		rotation globale de la prim rotation globale de la prim rotation globale de l'avatar rotation globale de l'avatar multipliée par la rotation globale de la prim (Inutile)
llGetLocalRot rotation globale de la prim rotation de la prim relative au prim racine rotation de l'attachement relative au point d'attachement rotation de la prim relative à la prim racine de l'attachement
llGetGlobalRotation rotation globale de la prim rotation globale de la prim racine rotation globale de l'avatar rotation globale de l'avatar
llSetRot(*)
llSetPrimitiveParams(*) 		change la rotation globale compliqué, voir llSetRot change la rotation relative à l'avatar change la rotation en la rotation globale de la racine multipliée par la nouvelle rotation
llSetLocalRot(*) change la rotation globale change la rotation de la prim par rapport à la prim racine change la rotation globale par rapport à l'avatar change la rotation de la prim par rapport à la prim racine de l'attachement
llTargetOmega† fait tourner l'ensemble lié autour du centre de la prim fait tourner la prim autour de son centre fait tourner l'ensemble lié autour du centre de l'attachement fait tourner la prim autour de son centre
*  Les objets physiques qui ne sont pas des fils dans un ensemble lié ne répondront pas aux changements de rotations
†  Pour les objets non physiques, llTargetOmega est exécuté du côté du client, ce qui donne une méthode à faible lag pour obtenir des rotations fluides et continues

Rotation de vecteurs

Dans LSL, faire pivoter un vecteur est très utile quand vous voulez faire bouger un objet suivant un arc de cercle, mais que le centre de la rotation n'est pas le centre de l'objet.

Ca peut sembler très compliqué, mais c'est beaucoup plus simple qu'il n'y paraît. Rappelez vous de la partie ci dessus sur la rotation de flèche, et remplacez la flèche par un vecteur dont l'origine est la queue de la flèche et dont les composants X, Y et Z indiquent la position de la pointe de la flèche. Faire tourner la flèche autour de sa queue fait bouger sa pointe suivant un arc dont le centre est la queue de la flèche. De la même façon, faire tourner un vecteur qui représente un décalage par rapport au centre de la prim la fait pivoter suivant le même arc. L'objet pivote autour d'une position qui est décalée par rapport au centre de la prim par le vector.

rotation rot30X = llEuler2Rot(<30, 0,0> * DEG_TO_RAD ); // crée une rotation constante, 30 degrés autour de l'axe X
vector decalage = <0, 1, 0>; // décale d'un mètre dans la direction Y positive
vector decalageTourne = decalage * rot30X; // fait tourner le vecteur décalage pour obtenir le mouvement donné par la rotation
vector nouvellePos = llGetPos() + decalageTourne; // déplace la position de la prim en fonction du décalage tourné

Nota Bene: Ceci est un mouvement, donc prenez garde aux problèmes qui se posent lorsqu'un objet est bougé hors du monde, sous le sol, de plus de 10 mètres, etc...

Constantes

ZERO_ROTATION

ZERO_ROTATION = <0.0, 0.0, 0.0, 1.0>;
Une constante de rotation correspondant à un angle d'Euler de <0.0, 0.0, 0.0>.

DEG_TO_RAD

DEG_TO_RAD = 0.01745329238f;
Une constante float qui donne l'angle en radians quand on multiplie l'angle en degrés par elle.

RAD_TO_DEG

RAD_TO_DEG = 57.29578f;
Une constante float qui donne l'angle en degrés quand on multiplie l'angle en radians par elle.

Retrieved from "https://wiki.secondlife.com/w/index.php?title=Rotation/fr&oldid=46456"