Second Life Wiki - User contributions [en]

LlSetStatus

2010-12-16T14:13:29Z

Joshua Philgarlic: Undo revision 1128561 by Joshua Philgarlic (Talk)

{{Issues/SVC-6549}}{{Issues/SVC-5531}}{{Issues/SVC-1773}}{{Issues/SVC-4197}}{{Issues/SVC-5723}}{{LSL_Function/boolean|value|bool=*}}{{LSL_Function
|func_id=45|func_sleep=0.0|func_energy=10.0
|func=llSetStatus
|p1_type=integer|p1_name=status|p1_desc=bit mask, STATUS_* flags
|p2_type=integer|p2_name=value
|func_footnote
|func_desc=Sets the object status attributes indicated in the '''status''' mask to '''value'''
|return_text
|spec
|caveats=*Status is an object attribute; all prims in an object share the same status.
** Except for [[STATUS_BLOCK_GRAB]], this only affects the prim the script is in, child prims in linked objects will not be affected.
***Use [[STATUS_BLOCK_GRAB_OBJECT]] to block grabbing of a link_set.
*STATUS_PHYSICS fails silently in attached objects, regardless of setting.
|constants={{LSL Constants/Status}}
|examples=<lsl>default
{
state_entry()
{
llSetStatus( STATUS_DIE_AT_EDGE | STATUS_PHYSICS, TRUE);
llSetStatus( STATUS_ROTATE_X | STATUS_ROTATE_Y, FALSE);
}
}</lsl>

|helpers
|also_functions=
{{LSL DefineRow||[[llGetStatus]]|Gets the object status.}}
|also_tests
|also_events
|also_articles
|notes
|cat1
|cat2=Status
|cat3=Physics
|cat4
}}

LlSetStatus

2010-12-16T02:26:01Z

Joshua Philgarlic:

{{Issues/SVC-5531}}{{Issues/SVC-1773}}{{Issues/SVC-4197}}{{Issues/SVC-5723}}{{LSL_Function
|func_id=45|func_sleep=0.0|func_energy=10.0
|func=llSetStatus
|p1_type=integer|p1_name=status|p1_desc=bit mask, STATUS_* flags
|p2_type=integer|p2_name=value|p2_desc=boolean
|func_footnote
|func_desc=Sets the object status attributes indicated in the '''status''' mask to '''value'''
|return_text
|spec
|caveats=*Status is an object attribute; all prims in an object share the same status.
** Except for STATUS_BLOCK_GRAB, this only affects the prim the script is in, child prims in linked objects will not be affected.
*STATUS_PHYSICS fails silently in attached objects, regardless of setting
|constants={{LSL Constants/Status}}
|examples=<lsl>default
{
state_entry()
{
llSetStatus( STATUS_DIE_AT_EDGE | STATUS_PHYSICS, TRUE);
llSetStatus( STATUS_ROTATE_X | STATUS_ROTATE_Y, FALSE);
}
}</lsl>

|helpers
|also_functions=
{{LSL DefineRow||[[llGetStatus]]|Gets the object status.}}
|also_tests
|also_events
|also_articles
|notes
|cat1
|cat2=Status
|cat3=Physics
|cat4
}}

User:Joshua Philgarlic

2008-10-06T08:52:38Z

Joshua Philgarlic:

== Joshua Philgarlic ==

[[Image:2008_02_11_004.jpg|left|thumb|Joshua Philgarlic]]
Hi, I'm Josh from Germany. I speak English, German and [[LSL Portal|LSL]].

I live in {{SLurl|region=Atmosphere|x=228|y=171|z=25|title=Atmosphere}} and I own a little shop. Don't forget to visit my volcano!
{{skills
|Builder=*
|Scripter=*
|}}

User:Joshua Philgarlic

2008-10-06T08:51:57Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-10-06T08:51:32Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-10-06T08:48:47Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-10-06T08:47:37Z

Joshua Philgarlic:

== Joshua Philgarlic ==

[[Image:2008_02_11_004.jpg|left|thumb|Joshua Philgarlic]]
Hi, I'm Josh from Germany. I speak English, German and [[LSL Portal|LSL]].

I'm living in {{SLurl|region=Atmosphere|x=228|y=171|z=25|title=Atmosphere}} and I own a little shop. Don't forget to visit my volcano!
{{skills
|Builder=
|Scripter=*
|}}

Linden Vehicle Tutorial/fr

2008-03-11T19:42:10Z

Joshua Philgarlic: The "< >" in "rotation rot =llEuler2Rot(<0, PI/2, 0>);" have been missing.

{{Multi-lang}}{{LSL_Header/fr}}

== Les Véhicules ==

La création de véhicules dans Second Life est une nouvelle fonctionnalité à présent disponible via le LSL. Ce tutorial détaille les bases nécessaires à la création de ces véhicules, des informations complémentaires sont consultables dans les pages relatives aux fonctions et aux codes décrits ici.

Il existe, à ce jour, deux méthodes permettant de rendre un objet mobile dans SL. L’une d’elle consiste à le transformer en véhicule. Cette méthode est suffisamment souple pour créer des véhicules qui glissent, lévitent, volent ou flottent. De plus certains comportements spécifiques peuvent être créés :
*Le contrôle des moteurs linéaires et angulaires pour pousser un objet dans une direction ou le faire pivoter sur lui même.
*Le contrôle du braquage au niveau des vitesses linéaires et angulaires
*Le contrôle des frottements linéaires et angulaires.
*Le contrôle de la lévitation au dessus d’un terrain ou de l’eau ou à une altitude fixe.
*Le contrôle de l’inclinaison dans les virages.

== Vue Générale ==

Il est possible de configurer le comportement d’un objet grâce aux fonctions [[llSetVehicleType/fr|llSetVehicleType]],
[[llSetVehicleFloatParam/fr|llSetVehicleFloatParam]], [[llSetVehicleVectorParam/fr|llSetVehicleFloatParam]], [[llSetVehicleRotationParam/fr|llSetVehicleRotationParam]], [[llSetVehicleFlags/fr|llSetVehicleFlags/fr]] et [[llRemoveVehicleFlags/fr|llRemoveVehicleFlags]].

Les fonctionnalités disponibles au travers de ces fonctions sont décrites un peu plus loin. La chose importante à noter ici est que le comportement d’un véhicule est défini par une série de paramètres ajustables. Ce sont ces paramètres qui permettront de décider si un objet pourra flotter comme un bateau ou glisser comme un traîneau.

Il existe par ailleurs, une série de codes permettant de déroger au fonctionnement standard. Une partie de ces codes ne sont par ailleurs effectifs que dans certaines situations.
Par exemple, le code [[VEHICLE_FLAG_HOVER_WATER_ONLY/fr|VEHICLE_FLAG_HOVER_WATER_ONLY]] fera léviter un objet sans tenir compte de l’altitude du terrain mais ce code ne fonctionnera que si l’objet est capable de léviter.

== Points d’attention==

La notion de véhicules a été récemment ajoutée à Second life et certains de leur comportement évolueront encore. Il est possible, par exemple, que les limites décrites dans la suite du document évoluent (ou aient même déjà évolué). Afin d’être sure d’avoir des informations à jour, n’hésitez pas à vous reporter aux fiches descriptives des fonctions et des valeurs.

Il n’est pas recommandé de mixer certaines fonctionnalités avec celles relatives aux véhicules.
Les fonctions permettant d’appliquer des poussées sur des objets ne doivent pas être combinées à celles relatives aux véhicules : [[llSetBuoyancy/fr|llSetBuoyancy]], [[llSetForce/fr|llSetForce]], [[llSetTorque/fr|llSetTorque]] et [[llSetHoverHeight/fr|llSetHoverHeight]]

Il est déconseiller de mixer les fonctions suivantes avec celles relatives aux véhicules aux risque de provoquer un comportement curieux ou inattendu : [[llLookAt/fr|llLookAt]], [[llRotLookAt/fr|llRotLookAt]], [[llMoveToTarget/fr|llMoveToTarget]] et [[llTargetOmega/fr|llTargetOmega]].

Si vous pensez avoir trouvé une anomalie relative aux véhicules, il vous est possible d’envoyer une copie de votre script à "Andrew Linden" avec un commentaire ou note explicative. Nommer vos envois "Bugged Vehicle XX" ou XX correspond à vos initiales. Le véhicule et le script seront examinés aussi vite que possible.

== Les définitions ==

Les termes ''roulis'' ou ''tangages'' et sont souvent utilisés pour décrire un type de rotation effectuée par des bateaux ou des avions selon un axe qui leur est relatif (par exemple, un bateau tangue selon un axe central à sa coque).

http://en.wikipedia.org/wiki/Tait-Bryan_angles

La « technique de la main droite » est souvent utilisée comme introduction aux cours de physique afin de définir les rotations positives. Un exemple courant consiste à utiliser la « technique de la main droite » pour modéliser le roulement d’un bateau ou d’un avion. Placez votre pouce dans l’axe de l’avion (axe x) et repliez les doigts vers l’intérieur de la main, votre main s’incline naturellement dans le sens ou l’avion devrait pivoter, votre main effectue une rotation dans le sens positif.

http://en.wikipedia.org/wiki/Right_hand_rule

La plupart des paramètres contrôlant le comportement des véhicules sont sous la forme : VEHICLE_'''COMPORTEMENT'''_TIMESCALE

Le délai (ou timescale) appliqué au '''COMPORTEMENT''' être interprétable comme le temps nécessaire pour que l’action induite fasse effet (délai entre la décision et son entière application). Les fonctions travaillent sur une échelle exponentielle, un cœfficient de 1/e est appliqué (''e'' correspond à l’exposant (environ 2.718281828)).
Si vous souhaitez un véhicule très maniable, utilisez un délai court (une seconde voire moins). Un délai de 300 secondes (5 minutes) ou plus désactivera un comportement.
Pour des raisons techniques, il existe un délai minimal de l’ordre du dixième de seconde. Mettre un délai à 0 sera toujours équivalent au plus petit délai possible.

== Paramétrer le type de véhicule ==

Avant de commencer à définir les paramètres d’un véhicule, il est indispensable d’indiquer le type de véhicule. Cette donnée est fixée avec la fonction [[llSetVehicleType/fr|llSetVehicleType]] et un paramètre de type '''VEHICLE_TYPE_*'''. Le paramètre [[VEHICLE_TYPE_NONE/fr|VEHICLE_TYPE_NONE]] désactivera le mode véhicule. Consultez la page sur {{LSLGC/fr|Vehicle|les types de véhicules}} pour connaître les options disponibles. Cette liste devrait s’agrandir avec le temps.

Paramétrer le type de véhicule est indispensable pour permettre à un objet de se comporter comme un véhicule et pour définir des paramètres par défaut.
Pour chaque type de véhicule, vous trouverez la liste des valeurs par défaut. Ce ne sont pas nécessairement des valeurs optimales et il est possible de les modifier. Il est obligatoire d’indiquer un type de véhicule même pour créer un véhicule original ou expérimental

Indiquer un type de véhicule ne rend pas automatiquement l’objet mobile, mais vous devriez éviter de créer un véhicule lorsque votre objet est libre de ces mouvements et placé au sommet d’une colline car il pourrait commencer à se déplacer tout seul.

Nous sommes toujours à la recherche de paramètres optimaux, si vous pensez avoir trouvé un jeu de règles plus réaliste ou efficace, vous pouvez les envoyer à Andrew Linden via un script ou une note.

== Le braquage linéaire et angulaire ==

Une fonction récurrente des véhicules réels est l’existence d’un axe préférentiel de déplacement. Cet axe vient de leurs roues, de leurs ailes, de leur forme ou de leur méthode de propulsion. Ils ont tendance à se déplacer selon cet axe et/ou d’y revenir naturellement. Cet axe est statique dans le référentiel du véhicule.

Prenons par exemple une fléchette, elle possède des palmes à l’arrière qui, par les frottements de l’air, est capable de naturellement s’aligner dans le sens du mouvement. C’est cet effet qui est appelé « braquage angulaire » (rotation de l’objet).

Un engin sur roues présente un effet différent, quand un skateboard est poussé dans une direction, il a tendance à se réorienter dans l’axe de roulement. C’est cet effet qui est appelé « braquage linéaire » (rotation de la vitesse)

Ainsi, un véhicule de Second Life est un véhicule avec un braquage linéaire et angulaire le long d’axes préférentiels dans le référentiel de la prim racine.
Prenons le cas d’un véhicule avec un axe préférentiel x :
* dans le cas du braquage linéaire, le script aura tendance à influer sur la direction jusqu'à ce qu’elle pointe dans le sens positif de l’axe x.
* dans le cas du braquage angulaire, le script aura tendance à influer sur le véhicule jusqu’à ce qu’il pointe dans le sens du mouvement.
Les fonctionnalités applicables aux autres axes, sont décrites plus loin, comme l’attracteur vertical qui soumet un véhicule à une force d’attraction (sur l’axe z)
Le référentiel du véhicule peut être différent de celui de la prim en utilisant [[VEHICLE_REFERENCE_FRAME/fr|VEHICLE_REFERENCE_FRAME]]. Cette fonctionnalité sera étudiée dans la suite du document.

Selon le type de véhicule, il peut être souhaitable d’avoir un braquage linéaire ou angulaire plus ou moins fort. La force (ou vitesse d’application) du braquage est contrôlée à l’aide la fonction [[llSetVehicleFloatParam/fr|llSetVehicleFloatParam]]

Les deux types de braquage ont un délai d’application (ou timescale) qui détermine à quelle vitesse le braquage influe sur le véhicule. Ce délai est un coefficient exponentiel représentant le temps nécessaire au braquage pour être entièrement appliqué au véhicule. Les véhicules se braquant rapidement doivent avoir un petit délai, par exemple une fléchette doit avoir un braquage angulaire de moins de 2 secondes et un braquage linéaire de plusieurs secondes, car elle aura tendance à se réorienter avant d’influer sur sa direction. Pour une fléchette, vous pourriez utiliser les paramètres suivants :
<pre>
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, 2.0);
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_TIMESCALE, 6.0);
</pre>
Chacun des braquages a un coefficient d’efficacité variant de 0.0 à 1.0, à la différence des autres paramètres, il ne va pas de « élastique» (0.0) à « amorti » (1.0) mais de « pas de braquage » (0.0) à « braquage maximum » (1.0). Ils se comportent un peu comme les délais d’application, mais sont normés entre 0 et 1.

== Le déplacement du véhicule ==

Une fois activé, le véhicule peut toujours être poussé et tourné par impulsion (forces extérieures ou scripts utilisant [[llApplyImpulse/fr|llApplyImpulse]]), mais il faut garder à l’esprit les moteurs linéaires et angulaires rendent les mouvements plus fluides et rendent les déplacement bien plus paramétrable. Le déplacement d’un véhicule peut être piloté avec la fonction [[llSetVehicleVectorParam/fr|llSetVehicleVectorParam]].
Pour déplacer un objet à 5 mètres/seconde le long de son axe x (l’axe de la vue subjective), il suffit d’ajouter la ligne suivante à votre script :
<pre>
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <5, 0, 0>);
</pre>
Pour éviter aux véhicules de se déplacer trop vite, la vitesse maximale est de 30 mètres/seconde. Cette limitation vient des contraintes du moteur physique de SL et pourra être étendue ultérieurement.

Jouer sur la vitesse ne suffit pas à créer des véhicules intéressants.
Vous pourriez par exemple vouloir créer une voiture capable d’atteindre immédiatement sa vitesse limite ou qui au contraire accélérerait progressivement. Cet effet peut être configuré avec le paramètre [[VEHICLE_LINEAR_MOTOR_TIMESCALE/fr|VEHICLE_LINEAR_MOTOR_TIMESCALE]]. Ce paramètre représente le temps nécessaire (sur une échelle exponentielle) au véhicule pour atteindre sa vitesse maximale.

Que se passerait il si vous lanciez un véhicule à la pleine vitesse (vitesse du moteur linéaire)? En théorie, le véhicule devrait partir en ligne droite et ne jamais s’arrêter.
En fait, ce phénomène est également configurable grâce à une fonction simulant une perte de vitesse progressive. Immédiatement après qu’un moteur ait été sollicité, il commence alors à réduire sa vitesse selon un délai paramétré par [[VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE/fr|VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE]]. De cette façon, passé un certain temps, les moteurs cessent d’avoir de l’effet et le véhicule s’arrête tout seul.

Vu que ce délai ne peut dépasse 120 secondes et qu’il est permanent, il garantit qu’un véhicule ne roulera jamais éternellement (sans action manuelle et sans boucle logique).

Ce paramètre peut être employé pour appliquer une impulsion. On peut par exemple configurer les touches haut/bas pour allumer ou atteindre le moteur d’une voiture, les deux touches modifie simplement le temps nécessaire au véhicule pour s’arrêter (délai court = moteur éteint, petite impulsion avant de s’arrêter ; délai long = moteur allumé, grand impulsion avant arrêt du véhicule).

Un moteur est réinitialisée à chaque fois que son paramétrage est modifié, un vector de vitesse nul n’a pas le même sens qu’une perte de vitesse rapide (délai nul). Dans le premier cas, le moteur va chercher à atteindre la vitesse nul, dans le second cas, le véhicule s’arrête immédiatement.

::[[VEHICLE_LINEAR_MOTOR_TIMESCALE/fr|VEHICLE_LINEAR_MOTOR_TIMESCALE]] est le temps nécessaire au moteur pour appliquer la nouvelle vitesse.

::[[VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE/fr|VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE]] est le temps nécessaire au moteur pour repasser à une vitesse nulle.

Mélanger les deux paramètres risque d’occasionner beaucoup de frustration vu leurs effets très différents...

De plus, si la perte de vitesse est plus rapide que le temps nécessaire pour atteindre la vitesse cible du véhicule, alors l’efficacité globale du moteur est diminuée en conséquence.

== L’orientation du véhicule ==

Tout comme le moteur linéaire, il existe également un moteur angulaire (toujours actif) et dont la direction et la puissance sont configurables. Par exemple pour faire tourner un véhicule de 5 degrés/seconde autour de son axe Z (axe haut/bas), il suffit d’ajouter les lignes suivantes à votre script :

<pre>
vector angular_velocity = <0, 0, 5 * PI / 180>;
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_velocity);
</pre>

Il n’est actuellement pas possible de réaliser plus de 2 rotations / seconde. (4*PI radians/sec).

Comme pour le moteur linéaire, il existe deux paramètres de temps :
[[VEHICLE_ANGULAR_MOTOR_TIMESCALE/fr|VEHICLE_ANGULAR_MOTOR_TIMESCALE]] et [[VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE/fr|VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE]] qui correspondent au temps nécessaire pour atteindre la vitesse maximale et au temps nécessaire pour repasser à une vitesse nulle (mis à 120 secondes par défaut)
Lorsque vous pivotez, vous souhaitez sûrement éviter que votre véhicule ne tourne trop vite ou trop longtemps. :
* Une façon de faire, consiste à utiliser le moteur angulaire avec une perte de vitesse longue mais avec un fort coefficient de frottement angulaire (de façon à provoquer une perte de vitesse rapide lorsque le moteur est arrêté). Puis d’appliquer une importante vitesse angulaire lorsque la touche est pressée et de repasser la vitesse à 0 lorsqu’elle est relâchée.
* Une autre façon de faire, consiste d’appliquer une petite durée au [[VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE/fr|VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE]] et d’utiliser une impulsion plus forte en jouant sur la réduction de la vitesse plutôt que sur les frottement.

Comme pour le moteur linéaire, une vitesse angulaire nulle est différente d’une perte de vitesse immédiate (délai nul). Une vitesse nulle imposera une transition depuis la vitesse actuelle du moteur angulaire, alors qu’un délai nul stoppera immédiatement la rotation.

Pour certains véhicules, il sera possible d’appliquer une inclinaison pour tourner. Cette inclinaison est visible lorsque des avions ou des motos effectuent un virage. Cette inclinaison est réalisée suivant l’axe de roulement du véhicule. Cette fonctionnalité n’est disponible que lorsque l’attracteur vertical (décrit plus bas) est activé.

== L’attracteur vertical ==

Certains véhicules comme les bateaux gardent toujours leur face supérieure orientée vers le haut. Ce phénomène peut être reproduit à l’aide de l’attracteur vertical qui permet d’exécuter de petits bonds le long de l’axe z.

Cette fonctionnalité s’utilise avec [[VEHICLE_VERTICAL_ATTRACTION_TIMESCALE/fr|VEHICLE_VERTICAL_ATTRACTION_TIMESCALE]] pour contrôler la période des rebonds (ou la vitesse d’amortissement) et [[VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY/fr|VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY]] pour contrôler le phénomène d’amortissement (0.0 : oscillations autour de la position d’équilibre // 1.0 : amortissement progressif vers la position d’équilibre)
<pre>
llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 4.0);
llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY, 0.5);
</pre>
L’attracteur vertical est désactivé si l’on positionne une période (ou timescale) supérieure à 300 secondes.

Il faut noter que l'attracteur vertical empêchera les véhicules de plonger et de grimper. Ainsi, si vous souhaitez réaliser une avion, il vous faudra probablement désactiver l'attracteur le long de l'axe de roulement à l'aide du code :[[VEHICLE_FLAG_LIMIT_ROLL_ONLY/fr|VEHICLE_FLAG_LIMIT_ROLL_ONLY]]

<pre>
llSetVehicleFlags(VEHICLE_FLAG_LIMIT_ROLL_ONLY);
</pre>

== L’inclinaison ==

Cette fonctionnalité permet de pivoter le véhicule au moyen de rotations sur l'axe de roulement du véhicule.
L'attracteur vertical doit être activé si l'on souhaite utiliser cette fonction.
L'amplitude de l'inclinaison est liée au paramètre [[VEHICLE_BANKING_COEF/fr|VEHICLE_BANKING_COEF]] qui indique l’amplitude de la rotation (et parfois la vitesse du véhicule autour de son axe préférentiel de déplacement).

Le paramètre varie entre -1 et +1.
* Si le paramètre est positif, lors d’une rotation positive le long de l'axe de roulement (inclinaison sur la droite) un couple négatif est appliqué ce qui fait tourner le véhicule à droite. C’est le phénomène observé sur les avions et les motos dans un virage.
* Si le paramètre est négatif, lors d’une rotation positive le long de l'axe de roulement (inclinaison sur la droite), un couple positif est appliqué, ce qui fait tourner le véhicule à gauche. Ce phénomène ne correspond à aucune réalité physique, mais peut être utilisé par exemple pour créer des véhicules atypiques.

Le paramètre [[VEHICLE_BANKING_MIX/fr|VEHICLE_BANKING_MIX]] permet de changer les critères d'inclinaison au lieu de laisser le moteur physique décider de l’inclinaison optimale.

Prenons par exemple une moto, dans la réalité, elle ne peut s’incliner que lorsqu’elle est en mouvement, alors que dans les jeux vidéo, elle est capable de s’incliner au point mort. L'interface des joueurs étant limitée, il est bien plus facile de contrôler un véhicule de cette façon.
Ce paramètre permet de combiner des inclinaisons réalistes et non réalistes. Il varie entre 0.0 (statique) et 1.0 (dynamique). "Statique" signifie que l'inclinaison dépend uniquement de la rotation de l'objet (application des lois physiques) alors que "dynamique" signifie que le vitesse de rotation est également prise en compte. Trouver la meilleure valeur nécessitera probablement beaucoup de tests.

Le temps nécessaire à l'inclinaison pour contrecarrer une vitesse angulaire préexistante le long de l'axe Z (et devenir visible) est déterminée par [[VEHICLE_BANKING_TIMESCALE/fr|VEHICLE_BANKING_TIMESCALE]]. Plus la valeur sera petite, plus l'inclinaison sera prise en compte rapidement.

== Les frottements (ou résistances) ==

[[VEHICLE_LINEAR_FRICTION_TIMESCALE/fr|VEHICLE_LINEAR_FRICTION_TIMESCALE]] est un vector qui configure, pour les 3 axes, le temps nécessaire au véhicule pour s'arrêter complètement (à cause des "frottements").

Les 3 valeurs sont dépendantes les unes des autres. Une voiture aura par exemple peu de frottement le long de son axe x et z (afin qu'elle puisse avancer, reculer, monter et descendre des pentes) alors qu'elle aura d'importants frottement le long de l'axe y (droite/gauche)

<pre>
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 3>);
</pre>

Plus le délai est important, plus faibles sont les frottements, par conséquent, il faut indiquer une valeur élevée pour désactiver ce phénomène le long d'un axe.

Il est possible d'indiquer le coefficient de frottement linéaire comme un scalaire (float). Ce choix a pour conséquence de donner la même valeur aux 3 champs.

Les deux exemples suivants sont similaires et rendent les frottements négligeables.
<pre>
// Positionne tous les temps d'arrêt par frottement à 1000
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 1000>);
// Idem, mais avec moins de données.
llSetVehicleFloatParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, 1000);
</pre>
[[VEHICLE_ANGULAR_FRICTION_TIMESCALE/fr|VEHICLE_ANGULAR_FRICTION_TIMESCALE]] est un paramètre de type vector qui définit le temps nécessaire au moteur angulaire pour s'arrêter à cause des frottements. Il fonctionne comme le paramètre du moteur linéaire.

== La flottabilité ==

Les véhicules ont une flottabilité indépendante de la fonction [[llSetBuoyancy/fr|llSetBuoyancy]]. Il est recommandé d'éviter de mélanger les deux fonctions.

Un véhicule acquière la flottabilité à l'aide du paramètre [[VEHICLE_BUOYANCY]] : 0.0 = aucune flottabilité // 1.0 = zéro gravité.

La flottabilité est différente de la lévitation.
Pour que la lévitation fonctionne sans risquer de décalage lors de l’emploi du paramètre [[VEHICLE_HOVER_HEIGHT/fr|VEHICLE_HOVER_HEIGHT]], le paramètre [[VEHICLE_BUOYANCY/fr|VEHICLE_BUOYANCY]] doit être positionné à 1.0

== La lévitation ==

La lévitation est activée lorsque la paramètre [[VEHICLE_HOVER_TIMESCALE/fr|VEHICLE_HOVER_TIMESCALE]] prend une valeur inférieure à 300 secondes (des valeurs supérieures désactivent également la fonctionnalité).
Ce paramètre indique le temps nécessaire au véhicule pour se mettre en lévitation.
La plupart des véhicules fonctionnent mieux avec un temps de lévitation de quelques secondes (voire moins). Plus le temps sera court, plus le comportement du véhicule sera influencé par son poids.

Il faut noter que les frottements (cf. [[VEHICLE_LINEAR_FRICTION_TIMESCALE/fr|VEHICLE_LINEAR_FRICTION_TIMESCALE]]) peuvent influencer la mise en lévitation.

La lévitation est indépendante de la flottabilité mais [[VEHICLE_BUOYANCY/fr|VEHICLE_BUOYANCY]] doit être mise à 1.0, sinon le véhicule ne lévitera pas tant que la hauteur cible de lévitation [[VEHICLE_HOVER_HEIGHT/fr|VEHICLE_HOVER_HEIGHT]] ne compense pas la gravité, de plus le véhicule ne flottera jamais à la bonne hauteur.

Le paramètre [[VEHICLE_HOVER_EFFICIENCY/fr|VEHICLE_HOVER_EFFICIENCY]] permet de configurer la lévitation, il varie de 0.0 (avec oscillation) à 1.0 (stable)
Lorsque le paramètre est à 0, le véhicule oscille à une altitude un peu plus basse que l'altitude cible et la période des oscillations correspond à peu près à celle définie par [[VEHICLE_HOVER_TIMESCALE/fr|VEHICLE_HOVER_TIMESCALE]] (la vraie période est un peu plus longue)

De part les limitations du moteur physique de SL, la lévitation ne prend en compte que les zones terrestres et marines, il est actuellement impossible de léviter au dessus de prims telles un pont ou une maison.

Par défaut un véhicule lévitera au dessus de l'eau et de la terre, certains paramètres permettent de modifier ce comportement :
[[VEHICLE_HOVER_WATER_ONLY/fr|VEHICLE_HOVER_WATER_ONLY]] est à utiliser pour les bateaux (lévitation en zone marine uniquement)
[[VEHICLE_HOVER_TERRAIN_ONLY/fr|VEHICLE_HOVER_TERRAIN_ONLY]] est à utiliser pour un tank susceptible d'aller sous l'eau (lévitation sur terre uniquement).
[[VEHICLE_HOVER_GLOBAL_HEIGHT/fr|VEHICLE_HOVER_GLOBAL_HEIGHT]] est à utiliser pour un sous-marin ou un ballon.
Ces codes ne sont pas compatibles, et les mélanger risque de générer des comportements atypiques. Ces codes sont à utiliser avec la fonction [[llSetVehicleFlags/fr|llSetVehicleFlags]].

Le paramètre [[VEHICLE_HOVER_HEIGHT/fr|VEHICLE_HOVER_HEIGHT]] permet de décider à quelle altitude le véhicule doit léviter (au dessus de l'eau, de la terre ou en hauteur absolue). La valeur maximale est de 100 mètres

Le point de lévitation est fixé par le centre de gravité (parfois difficile à repérer pour des personnes non entraînées), par ailleurs le centre change lorsqu'une personne est assise sur l'objet.

== Référentiels relatifs ==

Les véhicules se basent sur leurs axes x (avant/arrière), y (droite/gauche) et z (haut/bas) pour décider de leur mouvement. Par défaut ces axes sont identiques à ceux de la prim racine, mais cela suppose que la prim racine soit parfaitement orientée afin que les deux référentiels correspondent. Ce n'est pas toujours possible, comme, par exemple, dans le cas de véhicules préconstruits.

C'est dans ce type de situation que le paramètre [[VEHICLE_REFERENCE_FRAME/fr|VEHICLE_REFERENCE_FRAME]] devient utile car il permet de réorienter les axes du véhicule de manière indépendante du référentiel de la prim.

Par exemple, supposons que nous ayons construit une fusée à partir d'un grand cylindre, d'un cône pour l'avant et avec le cylindre comme prim principale.
Idéalement, la fusée devrait se déplacer le cône en 'avant, or l'axe de déplacement avant l'axe x (qui pointe à l'horizontal du sol). Le script suivant effectue une rotation de façon à ce que l'axe x, remplace l'axe z (vers le haut).
<pre>
// Tourne le référentiel du véhicule de -PI/2 autour de l'axe y (axe gauche/droite)
rotation rot =llEuler2Rot(<0, PI/2, 0>);
llSetVehicleRotationParam(VEHICLE_REFERENCE_FRAME, rot);
</pre>

Un autre exemple : Prenons une navette spatiale qui souhaite voler l'horizontalement avec l'attracteur vertical mais décoller et atterrir verticalement (également avec l'attracteur). En vol, le nez de la navette doit être vers l'avant, mais lors de l'atterrissage, il doit être orienté vers le haut. Pour que la navette puisse atterrir avec l'attracteur actif, il suffit d'effectuer un rotation du référentiel de +PI/2 selon l'axe y, de cette façon, la tête de la navette se relève et permet l'atterrissage. Tout en conservant l'attracteur, la navette pourra se poser en utilisant les frottements ou une diminution de la lévitation pour se poser.

{{LSLC/fr|Vehicle|Tutoriels}} {{LSLC/fr|Tutorials|Vehicules}}

Linden Vehicle Tutorial

2008-03-11T19:39:49Z

Joshua Philgarlic: The "< >" in "rotation rot =llEuler2Rot(<0, PI/2, 0>);" have been missing.

{{Multi-lang}}{{LSL_Header}}

== Vehicles ==

Vehicles are a new feature now available for use through LSL. This chapter will cover the basics of how vehicles
work, the terms used when describing vehicles, and a more thorough examination of the api available.

There are several ways to make scripted objects move themselves around. One way is to turn the object into a
"vehicle". This feature is versatile enough to make things that slide, hover, fly, and float. Some of the behaviors
that can be enabled are:

*deflection of linear and angular velocity to preferred axis of motion
*asymmetric linear and angular friction
*hovering over terrain/water or at a global height
*banking on turns
*linear and angular motor for push and turning

== Overview ==

Each scripted object can have one vehicle behavior that is configurable through the[[llSetVehicleType]],
llSetVehicleFloatParam,llSetVehicleVectorParam,llSetVehicleRotationParam,llSetVehicleFlags, and
llRemoveVehicleFlags library calls.

These script calls are described in more detail below, but the important thing to notice here is that the vehicle
behavior has several parameters that can be adjusted to change how the vehicle handles. Depending on the values
chosen the vehicle can veer like a boat in water, or ride like a sled on rails.

Setting the vehicle flags allow you to make exceptions to some default behaviors. Some of these flags only have
an effect when certain behaviors are enabled. For example, the [[VEHICLE_FLAG_HOVER_WATER_ONLY]] will
make the vehicle ignore the height of the terrain, however it only makes a difference if the vehicle is hovering.

== Warnings ==

Vehicles are new in Second Life 1.1 and some of the details of their behavior may be changed as necessary to
ensure stability and user safety. In particular, many of the limits and defaults described in the appendices will
probably change and should not be relied upon in the long term.

It is not recommended that you mix vehicle behavior with some of the other script calls that provide impulse and
forces to the object, especially[[llSetBuoyancy]],[[llSetForce]],[[llSetTorque]], and[[llSetHoverHeight]].

While the following methods probably don’t cause any instabilities, their behavior may conflict with vehicles
and cause undesired and/or inconsistent results, so use[[llLookAt]],[[llRotLookAt]],[[llMoveToTarget]], and
[[llTargetOmega]] at your own risk.

If you think you have found a bug relating to how vehicle’s work, one way to submit the problem is to give a
copy of the vehicle and script to Andrew Linden with comments or a notecard describing the problem. Please
name all submissions "Bugged Vehicle XX" where XX are your Second Life initials. The vehicle and script will
be examined at the earliest convenience.

== Definitions ==

The terms "roll", "pitch", and "yaw" are often used to describe the modes of rotations that can happen to a
airplane or boat. They correspond to rotations about the local x-, y-, and z-axis respectively.
z-axis .

http://en.wikipedia.org/wiki/Tait-Bryan_angles

The right-hand-rule, often introduced in beginning physics courses, is used to define the direction of positive
rotation about any axis. As an example of how to use the right hand rule, consider a positive rotation about the
roll axis. To help visualize how such a rotation would move the airplane, place your right thumb parallel to the
plane’s roll-axis such that the thumb points in the positive x-direction, then curl the four fingers into a fist. Your
fingers will be pointing in the direction that the plane will spin.

http://en.wikipedia.org/wiki/Right_hand_rule

Many of the parameters that control a vehicle’s behavior are of the form:

VEHICLE_'''BEHAVIOR'''_TIMESCALE

A '''BEHAVIOR''' ’s "timescale" can usually be understood as the time for the
behavior to push, twist, or otherwise affect the vehicle such that the difference between what it is doing, and
what it is supposed to be doing, has been reduced to 1/e of what it was, where "e" is the natural exponent
(approximately 2.718281828). In other words, it is the timescale for exponential decay toward full compliance to
the desired behavior. When you want the vehicle to be very responsive use a short timescale of one second or
less, and if you want to disable a behavior then set the timescale to a very large number like 300 (5 minutes) or
more. Note, for stability reasons, there is usually a limit to how small a timescale is allowed to be, and is usually
on the order of a tenth of a second. Setting a timescale to zero is safe and is always equivalent to setting it to its
minimum. Any feature with a timescale can be effectively disabled by setting the timescale so large that it would
take them all day to have any effect.

== Setting the Vehicle Type ==

Before any vehicle parameters can be set the vehicle behavior must first be enabled. It is enabled by calling
[[llSetVehicleType]] with any '''VEHICLE_TYPE_*''', except [[VEHICLE_TYPE_NONE]] which will disable the
vehicle. See the {{LSLGC|Vehicle|vehicle types}} constants section for currently available types. More types will be available soon.

Setting the vehicle type is necessary for enabling the vehicle behavior and sets all of the parameters to its default
values. For each vehicle type listed we provide the corresponding equivalent code in long format. Is is important
to realize that the defaults are not the optimal settings for any of these vehicle types and that they will definitely
be changed in the future. Do not rely on these values to be constant until specified.

Should you want to make a unique or experimental vehicle you will still have to enable the vehicle behavior with
one of the default types first, after which you will be able to change any of the parameters or flags within the
allowed ranges.

Setting the vehicle type does not automatically take controls or otherwise move the object. However should you
enable the vehicle behavior while the object is free to move and parked on a hill then it may start to slide away.

We’re looking for new and better default vehicle types. If you think you’ve found a set of parameters that make a
better car, boat, or any other default type of vehicle then you may submit your proposed list of settings to
Andrew Linden via a script or notecard.

== Linear and Angular Deflection ==

A common feature of real vehicles is their tendency to move along "preferred axes of motion". That is, due to
their wheels, wings, shape, or method of propulsion they tend to push or redirect themselves along axes that are
static in the vehicle’s local frame. This general feature defines a class of vehicles and included in this category a
common dart is a "vehicle": it has fins in the back such that if it were to tumble in the air it would eventually
align itself to move point-forward -- we’ll call this alignment effect angular deflection.

A wheeled craft exhibits a different effect: when a skateboard is pushed in some direction it will tend to redirect
the resultant motion along that which it is free to roll -- we’ll call this effect linear deflection.

So a typical Second Life vehicle is an object that exhibits linear and/or angular deflection along the "preferential
axes of motion". The default preferential axes of motion are the local x- (at), y- (left), and z- (up) axes of the
local frame of the vehicle’s root primitive. The deflection behaviors relate to the x-axis (at): linear deflection will
tend to rotate its velocity until it points along it’s positive local x-axis while the angular deflection will tend to
reorient the vehicle such that it’s x-axis points in the direction that it is moving. The other axes are relevant to
vehicle behaviors that are described later, such as the vertical attractor which tries to keep a vehicle’s local z-axis
pointed toward the world z-axis (up). The vehicle axes can be rotated relative to the object’s actual local axes by
using the [[VEHICLE_REFERENCE_FRAME]] parameter, however that is an advanced feature and is covered in
detail in a later section of these documents.

Depending on the vehicle it might be desirable to have lots of linear and/or angular delfection or not. The speed
of the deflections are controlled by setting the relevant parameters using the[[llSetVehicleFloatParam]] script call.

Each variety of deflection has a "timescale" parameter that determines how quickly a full deflection happens.

Basically the timescale it the time coefficient for exponential decay toward full deflection. So, a vehicle that
deflects quickly should have a small timescale. For instance, a typical dart might have a angular deflection
timescale of a couple of seconds but a linear deflection of several seconds; it will tend to reorient itself before it
changes direction. To set the deflection timescales of a dart you might use the lines below:
<pre>
llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE, 2.0);
llSetVehicleFloatParam(VEHICLE_LINEAR_DEFLECTION_TIMESCALE, 6.0);
</pre>
Each variety of deflection has an "efficiency" parameter that is a slider between 0.0 and 1.0. Unlike the other
efficiency parameter of other vehicle behaviors, the deflection efficiencies do not slide between "bouncy" and
"damped", but instead slide from "no deflection whatsoever" (0.0) to "maximum deflection" (1.0). That is, they
behave much like the deflection timescales, however they are normalized to the range between 0.0 and 1.0.

== Moving the Vehicle ==

Once enabled, a vehicle can be pushed and rotated by external forces and/or from script calls such as
[[llApplyImpulse]], however linear and angular motors have been built in to make motion easier and smoother.
Their directions can be set using the[[llSetVehicleVectorParam]] call. For example, to make the vehicle try to move
at 5 meters/second along its local x-axis (the default look-at direction) you would put the following line in your
script:
<pre>
llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <5, 0, 0>);
</pre>
To prevent vehicles from moving too fast the magnitude of the linear motor is clamped to be no larger than about
30 meters/second. Note that this is clamped mostly because of limitations of the physics engine, and may be
raised later when possible.

Setting the motor speed is not enough to enable all interesting vehicles. For example, some will want a car that
immediately gets up to the speed they want, while others will want a boat that slowly climbs up to its maximum
velocity. To control this effect you can use the [[VEHICLE_LINEAR_MOTOR_TIMESCALE]] parameter.

Basically the "timescale" of a motor is the time constant for the vehicle to exponentially accelerate toward its full
speed.

What would happen if you were to accidentally set the vehicle’s linear velocity to maximum possible speed and
then let go? It would run away and never stop, right? Not necessarily: an automatic "motor decay" has been built
in such that all motors will gradually decrease their effectiveness after being set.

Each time the linear motor’s vector is set its "grip" immediately starts to decay exponentially with a timescale
determined by the [[VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE]], such that after enough time the
motor ceases to have any effect. This decay timescale serves two purposes. First, since it cannot be set longer
than 120 seconds, and is always enabled it gaurantees that a vehicle will not push itself about forever in the
absence of active control (from keyboard commands or some logic loop in the script). Second, it can be used to
push some vehicles around using a simple impulse model. That is, rather than setting the motor "on" or "off"
depending on whether a particular key is pressed "down" or "up" the decay timescale can be set short and the
motor can be set "on" whenever the key transitions from "up" to "down" and allowed to automatically decay.

Since the motor’s effectiveness is reset whenever the motor’s vector is set, then setting it to a vector of length
zero is different from allowing it to decay completely. The first case will cause the vehicle to try to reach zero
velocity, while the second will leave the motor impotent.

The two motor timescales have very similar names, but have different effects, so try not to get them confused.

::[[VEHICLE_LINEAR_MOTOR_TIMESCALE]] is the time for motor to "win", and

::[[VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE]] is the time for the motor’s "effectiveness" to decay
toward zero. If you set one when you think you are changing the other you will have frustrating results. Also, if
the motor’s decay timescale is shorter than the regular timescale, then the effective magnitude of the motor
vector will be diminished.

== Steering the Vehicle ==

Much like the linear motor, there is also an angular motor that is always on, and whose direction and magnitude
can be set. For example, to make a vehicle turn at 5 degrees/sec around its local z-axis (its up-axis) you might
add the following lines to its script:
<pre>
vector angular_velocity = <0, 0, 5 * PI / 180>;
llSetVehicleVectorParam(VEHICLE_ANGULAR_MOTOR_DIRECTION, angular_velocity);
</pre>
The magnitude of the angular motor is capped to be no more than two rotations per second (4*PI radians/sec).

Also like the linear motor it has an efficiency parameter, [[VEHICLE_ANGULAR_MOTOR_TIMESCALE]], and a
motor decay parameter, [[VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE]], which is set to themaximum possible value of 120 seconds by default.

When steering a vehicle you probably don’t want it to turn very far or for very long. One way to do it using the
angular motor would be to leave the decay timescale long, enable a significant amount of angular friction (to
quickly slow the vehicle down when the motor is turned off) then set the angular motor to a large vector on a key
press, and set it to zero when the key is released. Another way to do it is to set the
[[VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE]] to a short value and push the vehicle about with a
more impulsive method that sets the motor fast on a key press down (and optionally setting the motor to zero on
a key up) relying on the automatic exponential decay of the motor’s effectiveness rather than a constant angular
friction.

Setting the angular motor to zero magnitude is different from allowing it to decay. When the motor completely
decays it no longer affects the motion of the vehicle, however setting it to zero will reset the "grip" of the vehicle
and will make the vehicle try to achieve zero angular velocity.

For some vehicles it will be possible to use the "banking feature" to turn. "Banking" is what airplanes and
motorcycles do when they turn. When a banking vehicle twists about its roll-axis there is a resultant spin around
its yaw-axis. Banking is only available when using the "vertical attractor" which is described below.

== The Vertical Attractor ==

Some vehicles, like boats, should always keep their up-side up. This can be done by enabling the "vertical
attractor" behavior that springs the vehicle’s local z-axis to the world z-axis (a.k.a. "up"). To take advantage of
this feature you would set the [[VEHICLE_VERTICAL_ATTRACTION_TIMESCALE]] to control the period of
the spring frequency, and then set the [[VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY]] to control the
damping. An efficiency of 0.0 will cause the spring to wobble around its equilibrium, while an efficiency of 1.0
will cause the spring to reach it’s equilibrium with exponential decay.
<pre>
llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 4.0);
llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY, 0.5);
</pre>
The vertical attractor is disabled by setting its timescale to anything larger than 300 seconds.

Note that by default the vertical attractor will prevent the vehicle from diving and climbing. So, if you wanted to
make a airplane you would probably want to unlock the attractor around the pitch axis by setting the
[[VEHICLE_FLAG_LIMIT_ROLL_ONLY]] bit:
<pre>
llSetVehicleFlags(VEHICLE_FLAG_LIMIT_ROLL_ONLY);
</pre>

== Banking ==

The vertical attractor feature must be enabled in order for the banking behavior to function. The way banking
works is this: a rotation around the vehicle’s roll-axis will produce a angular velocity around the yaw-axis,
causing the vehicle to turn. The magnitude of the yaw effect will be proportional to the

::[[VEHICLE_BANKING_COEF]], the angle of the roll rotation, and sometimes the vehicle’s velocity along its
preferred axis of motion.

::The [[VEHICLE_BANKING_COEF]] can vary between -1 and +1. When it’s positive then any positive rotation (by
the right-hand rule) about the roll-axis will effect a (negative) torque around the yaw-axis, making it turn to the
right -- that is the vehicle will lean into the turn, which is how real airplanes and motorcycle’s work. Negating
the banking coefficient will make it so that the vehicle leans to the outside of the turn (not very "physical" but
might allow interesting vehicles so why not?).

::The [[VEHICLE_BANKING_MIX]] is a fake (i.e. non-physical) parameter that is useful for making banking
vehicles do what you want rather than what the laws of physics allow. For example, consider a real motorcycle...
it must be moving forward in order for it to turn while banking, however video-game motorcycles are often
configured to turn in place when at a dead stop -- because they’re often easier to control that way using the
limited interface of the keyboard or game controller. The [[VEHICLE_BANKING_MIX]] enables combinations of
both realistic and non-realistic banking by fuctioning as a slider between a banking that is correspondingly
totally static (0.0) and totally dynamic (1.0). By "static" we mean that the banking effect depends only on the
vehicle’s rotation about its roll-axis compared to "dynamic" where the banking is also proportional to its
velocity along its roll-axis. Finding the best value of the "mixture" will probably require trial and error.

The time it takes for the banking behavior to defeat a pre-existing angular velocity about the world z-axis is
determined by the [[VEHICLE_BANKING_TIMESCALE]]. So if you want the vehicle to bank quickly then give it
a banking timescale of about a second or less, otherwise you can make a sluggish vehicle by giving it a timescale
of several seconds.

== Friction Timescales ==

[[VEHICLE_LINEAR_FRICTION_TIMESCALE]] is a vector parameter that defines the timescales for the vehicle
to come to a complete stop along the three local axes of the vehicle’s reference frame. The timescale along each
axis is independent of the others. For example, a sliding ground car would probably have very little friction along
its x- and z-axes (so it can easily slide forward and fall down) while there would usually significant friction along
its y-axis:
<pre>
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 3>);
</pre>
Remember that a longer timescale corresponds to a weaker friction, hence to effectively disable all linear friction
you would set all of the timescales to large values.

Setting the linear friction as a scalar is allowed, and has the effect of setting all of the timescales to the same
value. Both code snippets below are equivalent, and both make friction negligible:
<pre>
// set all linear friction timescales to 1000
llSetVehicleVectorParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, <1000, 1000, 1000>);
// same as above, but fewer characters
llSetVehicleFloatParam(VEHICLE_LINEAR_FRICTION_TIMESCALE, 1000);
</pre>
/[[VEHICLE_ANGULAR_FRICTION_TIMESCALE]] is also a vector parameter that defines the timescales for the
vehicle to stop rotating about the x-, y-, and z-axes, and are set and disabled in the same way as the linear friction.

== Buoyancy ==

The vehicle has a built-in buoyancy feature that is independent of the[[llSetBuoyancy]] call. It is recommended that
the two buoyancies do not mix! To make a vehicle buoyant, set the [[VEHICLE_BUOYANCY]] parameter to
something between 0.0 (no buoyancy whatsoever) to 1.0 (full anti-gravity).

The buoyancy behavior is independent of hover, however in order for hover to work without a large offset of the
[[VEHICLE_HOVER_HEIGHT]], the [[VEHICLE_BUOYANCY]] should be set to 1.0.

It is not recommended that you mix vehicle buoyancy with the[[llSetBuoyancy]] script call. It would probably
cause the object to fly up into space.

== Hover ==

The hover behavior is enabled by setting the [[VEHICLE_HOVER_TIMESCALE]] to a value less than 300
seconds; larger timescales totally disable it. Most vehicles will work best with short hover timescales of a few
seconds or less. The shorter the timescale, the faster the vehicle will slave to is target height. Note, that if the
values of [[VEHICLE_LINEAR_FRICTION_TIMESCALE]] may affect the speed of the hover.

Hover is independent of buoyancy, however the [[VEHICLE_BUOYANCY]] should be set to 1.0, otherwise the
vehicle will not lift itself off of the ground until the [[VEHICLE_HOVER_HEIGHT]] is made large enough to
counter the acceleration of gravity, and the vehicle will never float all the way to its target height.

The [[VEHICLE_HOVER_EFFICIENCY]] can be thought of as a slider between bouncy (0.0) and smoothed (1.0).

When in the bouncy range the vehicle will tend to hover a little lower than its target height and the
[[VEHICLE_HOVER_TIMESCALE]] will be approximately the oscillation period of the bounce (the real period
will tend to be a little longer than the timescale).

For performance reasons, until improvements are made to the Second Life physics engine the vehicles can only
hover over the terrain and water, so they will not be able to hover above objects made out of primitives, such as
bridges and houses. By default the hover behavior will float over terrain and water, however this can be changed
by setting some flags:

If you wanted to make a boat you should set the [[VEHICLE_HOVER_WATER_ONLY]] flag, or if you wanted to
drive a hover tank under water you would use the [[VEHICLE_HOVER_TERRAIN_ONLY]] flag instead. Finally,
if you wanted to make a submarine or a balloon you would use the [[VEHICLE_HOVER_GLOBAL_HEIGHT]].

Note that the flags are independent of each other and that setting two contradictory flags will have undefined
behavor. The flags are set using the script call[[llSetVehicleFlags()]].

The [[VEHICLE_HOVER_HEIGHT]] determines how high the vehicle will hover over the terrain and/or water, or
the global height, and has a maximum value of 100 meters. Note that for hovering purposes the "center" of the
vehicle is its "center of mass" which is not always obvious to the untrained eye, and it changes when avatar’s sit
on the vehicle.

== Reference Frame ==

The vehicle relies on the x- (at), y- (left), and z- (up) axes in order to figure out which way it preferres to move
and which end is up. By default these axes are identical to the local axes of the root primitive of the object,
however this means that the vehicle’s root primitive must, by default, be oriented to agree with the designed at,
left, and up axes of the vehicle. But, what if the vehicle object was already pre-built with the root primitive in
some non-trivial orientation relative to where the vehicle as a whole should move? This is where the

[[VEHICLE_REFERENCE_FRAME]] parameter becomes useful; the vehicle’s axes can be arbitrarily reoriented
by setting this parameter.

As an example, suppose you had built a rocket out of a big cylinder, a cone for the nose, and some stretched cut
boxes for the fins, then linked them all together with the cylinder as the root primitive. Ideally the rocket would
move nose-first, however the cylinder’s axis of symmetry is its local z-axis while the default "at-axis" of the
vehicle, the axis it will want to deflect to forward under angular deflection, is the local x-axis and points out from
the curved surface of the cylinder. The script code below will rotate the vehicle’s axes such that the local z-axis
becomes the "at-axis" and the local negative x-axis becomes the "up-axis":
<pre>
// rotate the vehicle frame -PI/2 about the local y-axis (left-axis)
rotation rot =llEuler2Rot(<0, PI/2, 0>);
llSetVehicleRotationParam(VEHICLE_REFERENCE_FRAME, rot);
</pre>
Another example of how the reference frame parameter could be used is to consider flying craft that uses the
vertical attractor for stability during flying but wants to use VTOL (vertical takeoff and landing). During flight
the craft’s dorsal axis should point up, but during landing its nose-axis should be up. To land the vehicle: while
the vertical attractor is in effect, rotate the existing [[VEHICLE_REFERENCE_FRAME]] by +PI/2 about the
left-axis, then the vehicle will pitch up such that its nose points toward the sky. The vehicle could be allowed to
fall to the landing pad under friction, or a decreasing hover effect.

{{LSLC|Vehicle|Tutorial}} {{LSLC|Tutorials|Vehicle}}

User:Joshua Philgarlic

2008-02-25T13:08:51Z

Joshua Philgarlic:

== Joshua Philgarlic ==

[[Image:2008_02_11_004.jpg|left|thumb|Joshua Philgarlic]]
Hi, I'm Josh from Germany. I speak English, German and [[LSL Portal|LSL]].

I'm living in {{SLurl|region=Neum|x=203|y=41|z=23|title=Neum}} and I own two little shops. In my free time I try to help residents as a mentor.
{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

User:Joshua Philgarlic

2008-02-25T13:04:15Z

Joshua Philgarlic:

== Joshua Philgarlic ==

Hi, I'm Josh from Germany. I speak English, German and [[LSL Portal|LSL]].

I'm living in {{SLurl|region=Neum|x=203|y=41|z=23|title=Neum}} and I own two little shops. In my free time I try to help residents as a mentor.
[[Image:2008_02_11_004.jpg|left|frame|128px|Joshua Philgarlic]]
{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

User:Joshua Philgarlic

2008-02-25T13:00:28Z

Joshua Philgarlic:

== Joshua Philgarlic ==

Hi, I'm Josh from Germany. I speak English, German and [[LSL Portal|LSL]].

I'm living in [http://slurl.com/secondlife/Neum/203/41/23 Neum] and I own two little shops. In my free time I try to help residents as a mentor.
[[Image:2008_02_11_004.jpg|left|frame|128px|Joshua Philgarlic]]
{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

User:Joshua Philgarlic

2008-02-25T13:00:10Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-02-25T12:48:13Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-02-21T21:50:53Z

Joshua Philgarlic:

== Joshua Philgarlic ==

Hi, I'm Josh from Germany. I speak English, German and LSL.

I'm living in [http://slurl.com/secondlife/Neum/203/41/23 Neum] and I own two little shops. In my free time I try to help residents as a mentor.
[[Image:2008_02_11_004.jpg|left|frame|128px|Joshua Philgarlic]]
{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

File:2008 02 11 004.jpg

2008-02-21T21:43:29Z

Joshua Philgarlic:

User:Joshua Philgarlic

2008-02-19T19:47:12Z

Joshua Philgarlic:

== Joshua Philgarlic ==

Hi, I'm Josh from Germany. I speak English, German and LSL.

I'm living in [http://slurl.com/secondlife/Neum/203/41/23 Neum] and I own two little shops. In my free time I try to help residents as a mentor.

{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

User:Joshua Philgarlic

2008-02-19T19:41:37Z

Joshua Philgarlic:

== Joshua Philgarlic ==

Hi, I'm Josh from Germany. I speak English, German and LSL.

{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}

User:Joshua Philgarlic

2008-02-19T19:37:53Z

Joshua Philgarlic: New page: I'm Joshua Philgarlic from Germany. I speak English, German and LSL. {{ISO_639-3/cat-speaking/Volunteers|eng}} {{ISO_639-3/cat-speaking/Volunteers|deu}} {{visl |Men...

I'm Joshua Philgarlic from Germany. I speak English, German and LSL.
{{ISO_639-3/cat-speaking/Volunteers|eng}}
{{ISO_639-3/cat-speaking/Volunteers|deu}}
{{visl
|Mentors=*
|}}
{{skills
|Builder=
|Scripter=*
|}}