OpenSim: Test Véhicules

De OSWiki
Aller à la navigation Aller à la recherche

Généralités

Contrôles possibles

  • moteurs linéaires et angulaires,
  • braquage au niveau des vitesses linéaires et angulaires,
  • frottements linéaires et angulaires,
  • lévitation au dessus d’un terrain ou de l’eau ou à une altitude fixe
  • l’inclinaison dans les virages.

Les fonctions de véhicules

llSetVehicleType

Définit le type de véhicule parmi l'un des types par défaut. Partiellement implémentée dans OpenSim.

  • VEHICLE_TYPE_NONE : Désactive le mode véhicule
  • VEHICLE_TYPE_SLED : Véhicule de type traineau (cogne contre le sol et se déplace mieux sur son axe x.)
  • VEHICLE_TYPE_CAR : Véhicule qui rebondit sur le sol mais dont les moteurs doivent être pilotés par des commandes externes ou des événements de type timer.
  • VEHICLE_TYPE_BOAT : Véhicule de type bateau (flotte sur l'eau avec beaucoup de frottement et un freinage angulaires important.)
  • VEHICLE_TYPE_AIRPLANE : Véhicule de type avion (Utilise la déflexion linéaire pour la portance,le frein fait monter, pas de vol stationnaire et utilisation de l'inclinaison pour tourner.
  • VEHICLE_TYPE_BALLOON : Véhicule de type dirigeable (Vol stationnaire, et friction, mais sans freinage)

llSetVehicleFloatParam

Définit le paramètre param de type float à une des constantes prédéfinies. Partiellement implémentée dans OpenSim.

Moteur angulaire (tourner)

  • VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY : Braquage : va de 0 (aucun) à 1 (braquage maximal)
  • VEHICLE_ANGULAR_DEFLECTION_TIMESCALE : Temps nécessaire au véhicule pour réaliser un braquage angulaire complet.
  • VEHICLE_ANGULAR_FRICTION_TIMESCALE : Temps nécessaire à la réduction de la vitesse angulaire sur les 3 axes du véhicule.
  • VEHICLE_ANGULAR_MOTOR_TIMESCALE  : Temps nécessaire au véhicule pour atteindre sa vitesse angulaire cible.
  • VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE  : Temps nécessaire à la réduction de la vitesse du moteur angulaire.

Inclinaison

Fonctionnalité disponible que lorsque l’attracteur vertical est activé.

  • VEHICLE_BANKING_EFFICIENCY : Inclinaison dans les virages : -1 (inclinaison vers l'extérieur), 0 (pas d'inclinaison) et +1 (inclinaison vers l’intérieur)
  • VEHICLE_BANKING_MIX : Uniformité de l'inclinaison : va de 0 (inclinaison statique) à 1 (inclinaison dynamique)
  • VEHICLE_BANKING_TIMESCALE : Temps nécessaire au véhicule pour que inclinaison dans les virages prenne complètement effet.

Hauteur / Lévitation

  • VEHICLE_BUOYANCY : Levitation : va de -1 (gravité-double) et 1 (zéro gravité)
  • VEHICLE_HOVER_HEIGHT : Hauteur cible de la lévitation.
  • VEHICLE_HOVER_EFFICIENCY : Efficacité de la lévitation : va de 0 (élastique) et 1 (amortissement important)
  • VEHICLE_HOVER_TIMESCALE : Temps nécessaire au véhicule pour atteindre sa hauteur de lévitation

Moteur linéaire

  • VEHICLE_LINEAR_DEFLECTION_EFFICIENCY : Efficacité du freinage : va de 0 (aucun freinage) à 1 (freinage maximal)
  • VEHICLE_LINEAR_DEFLECTION_TIMESCALE : Temps nécessaire au véhicule pour réorienter la vitesse selon l'axe x.
  • VEHICLE LINEAR MOTOR TIMESCALE : Temps nécessaire au véhicule pour atteindre sa vitesse linéaire cible.
  • VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE : Temps nécessaire au moteur pour repasser à une vitesse nulle. Valeur Maximale : 120 secondes.Ne pas utiliser avec VEHICLE LINEAR MOTOR TIMESCALE.

Attracteur vertical

Empêche les véhicules de plonger et de grimper utiliser VEHICLE_FLAG_LIMIT_ROLL_ONLY pour le désactiver voir llSetVehicleFlags.

  • VEHICLE_VERTICAL_ATTRACTION_TIMESCALE : Temps nécessaire au véhicule pour aligner son axe z sur celui du monde (verticale). Désactivé avec une période supérieure ou égale à 300 secondes.
  • VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY : Attraction au sol : va de 0 (légère) à 1 (forte) le long de l'axe z du monde(axe vertical)

Exemple : 

llSetVehicleVectorParam(VEHICLE_VERTICAL_ATTRACTION_TIMESCALE, 4.0);

llSetVehicleVectorParam

Définit le paramètre param à l'aide d'un vecteur . Partiellement implémentée dans OpenSim.

  • VEHICLE_LINEAR_MOTOR_DIRECTION : Déplace le véhicule. Limite suprieure de la vitesse : 30 mètres/seconde.
  • VEHICLE_ANGULAR_MOTOR_DIRECTION : Vitesse angulaire cible du véhicule. Fait tourner un véhicule de x degrés/seconde autour d'un ou plusieurs axes.

Limite supérieure : 2 rotations / seconde. (4*PI radians/sec).

Exemple : Faire tourner un objet sur son axe z de 5 degrés par seconde. 

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

llSetVehicleRotationParam

Définit le paramètre param à l'aide d'une rotation. Partiellement implémentée dans OpenSim.

  • VEHICLE_REFERENCE_FRAME : Rotation des axes du véhicule.

llSetVehicleFlags

Pas implémentée dans OpenSim

llApplyImpulse

  • Applique une impulsion à l'objet.
  • Implémentée partiellement dans OpenSim

llRemoveVehicleFlags

Pas implémentée dans OpenSim

Quelques infos

Délais

  • Très maniable : délai court, 1 seconde ou moins.
  • Désactiver un comportement : 300 secondes (5 minutes) ou plus.
  • Délai 0 : équivalent au plus petit délai possible mais n'est pas 0.

Braquage

Ainsi, un véhicule dans opensim 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.

Étapes

Définir le type de véhicule

  • Avant que l'objet soit physique
  • Voir la liste
  • Pour chaque type il existe des paramètres par défaut.

Définir l'état physique de l'objet

  • llSetStatus(STATUS_PHYSICS, TRUE);
  • llSetPrimitiveParams([ PRIM_PHYSICS, integer boolean ]);
  • llSetPhysicsMaterial( integer mask, float gravity_multiplier, float restitution, float friction, float density );

Définir des paramètres

  • Voir ci-dessus.

Appliquer une force

  • llApplyImpulse
  • llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <5, 0, 0>)

Tests de scripts

Chute d'objets

  • Ce script permet de faire tomber un objet plus ou moins vite.
  • On peut s'asseoir sur l'objet.
  • Le deuxième paramètre correspond à la gravité, 0.9 c'est comme sur terre, 0.1 c'ets très très lent.
  • Types de véhicules :
    • Avec VEHICLE_TYPE_CAR : tombe assez droit, sur un terrain plat l'objet s'enfonce un peu dans le sol
    • Avec VEHICLE_TYPE_SLED : il ne descend pas droit mais une force le pousse (le vent ?) et accélère. Il sort de la région rapidement.
    • Avec VEHICLE_TYPE_BOAT : L'objet ne bouge pas.
    • VEHICLE_TYPE_AIRPLANE : tombe assez droit et glisse un peu sur le sol, pas très longtemps.
    • VEHICLE_TYPE_BALLOON : tombe tout droit, s'enfonce pas mal dans le sol.

<syntaxhighlight lang ='lsl'> 

default

{ 

   state_entry()
   {
      llSetVehicleType(VEHICLE_TYPE_CAR);
      llSetPhysicsMaterial(GRAVITY_MULTIPLIER | RESTITUTION | FRICTION | DENSITY, 0.2,0.9,1.0,1.0); 
      llSetPrimitiveParams([ PRIM_PHYSICS, TRUE ]);
   }

} </syntaxhighlight>

Ballon

  • Si on ajoute le paramètre VEHICLE_HOVER_HEIGHT avec une hauteur,
    • Avec VEHICLE_TYPE_CAR : L'objet est ralenti
    • Avec VEHICLE_TYPE_SLED : trajectoire oblique comme un téléphérique avec accélération.
    • Avec VEHICLE_TYPE_BOAT : l'objet monte plus haut
    • VEHICLE_TYPE_AIRPLANE : descend très lentement , pivote.
    • VEHICLE_TYPE_BALLOON : le ballon monte et reste à sa position.

<syntaxhighlight lang ='lsl'> default { 

   state_entry()
   { 
      llSetVehicleType(VEHICLE_TYPE_BALLOON);
      llSetPhysicsMaterial(GRAVITY_MULTIPLIER | RESTITUTION | FRICTION | DENSITY, 0.2,0.9,1.0,1.0);
      llSetVehicleFloatParam(VEHICLE_HOVER_HEIGHT,35.0);
      llSetPrimitiveParams([ PRIM_PHYSICS, TRUE ]);
   }

} </syntaxhighlight>

Déplacement

<syntaxhighlight lang ='lsl'> float limite = 0.0;

default { 

   state_entry()
   { 
      llSetVehicleType(VEHICLE_TYPE_BALLOON );
      llSetPhysicsMaterial(GRAVITY_MULTIPLIER | RESTITUTION | FRICTION | DENSITY, 0.9,0.9,1.0,1.0);
      llSetVehicleFloatParam(VEHICLE_HOVER_HEIGHT,35.0);
      llSetPrimitiveParams([ PRIM_PHYSICS, TRUE ]);
      llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <15, 0, 0>);
      llSetTimerEvent(1.0);
   }
   timer()
   {
      limite +=1.0;
      if(limite > 10.0)
      {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 0>);
          llSetTimerEvent(0.0);
      } 
   }

} </syntaxhighlight>

Tourner

<syntaxhighlight lang ='lsl'> float limite = 0.0; vector origine= <72.0, 58.0, 35.0>; vector rotxyz = <0.00000, 0.00000, 90.00000>;

integer reset; default { 

   state_entry()
   { 
     vector pos;
     vector angles_in_radians = rotxyz*DEG_TO_RAD;
     rotation rot_xyzq = llEuler2Rot(angles_in_radians);
      llSetRot(rot_xyzq);
      llSetStatus(STATUS_PHYSICS, FALSE);
      do
      {
        osSetPrimitiveParams(llGetKey(),[PRIM_POSITION,origine]); 
        pos = llGetPos();
       }while(pos.y > origine.y );
        
      reset = osGetLinkNumber("reset");    
      
      llSetCameraEyeOffset(<-4.0, 0.0, 4.0>);
      llSetCameraAtOffset(<4.0, 0.0, 4.0>);   
      
      llSetVehicleType(VEHICLE_TYPE_BALLOON ); //VEHICULE 
      llSetPhysicsMaterial(GRAVITY_MULTIPLIER | RESTITUTION | FRICTION | DENSITY, 0.9,0.9,1.0,1.0);
      llSetVehicleFloatParam(VEHICLE_HOVER_HEIGHT,35.0);
      llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY,1.0);
      llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE,1.0);
      llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <15, 0, 0>);
      llSetStatus(STATUS_PHYSICS, TRUE);
      llSetTimerEvent(1.0);
   }
   touch_start(integer nbr)
   {
       integer lien = llDetectedLinkNumber(0);
       if(lien == reset)
       {
           llSetStatus(STATUS_PHYSICS, FALSE);
           llSleep(1.0);
           llResetScript();
       }
   }
   timer()
   {
      limite +=1.0;
      if(limite > 15.0)
      {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <15, -30, 0>);
      }
      if(limite > 25.0)
      {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 0>);
          llSetTimerEvent(0.0);
          llSetStatus(STATUS_PHYSICS, FALSE);
      } 
   }

} </syntaxhighlight>

Piloter

<syntaxhighlight lang ='lsl'> float limite = 0.0; integer reset; default { 

   state_entry()
   { 
     vector pos;
     vector origine = llGetPos();
      llSetStatus(STATUS_PHYSICS, FALSE);
      do
      {
        osSetPrimitiveParams(llGetKey(),[PRIM_POSITION,origine]); 
        pos = llGetPos();
       }while(pos.y > origine.y );
         
      reset = osGetLinkNumber("reset");      
      
      llSetCameraEyeOffset(<-4.0, 0.0, 4.0>);
      llSetCameraAtOffset(<4.0, 0.0, 4.0>);   
      
      llSetVehicleType(VEHICLE_TYPE_BALLOON ); //VEHICULE 
      llSetPhysicsMaterial(GRAVITY_MULTIPLIER | RESTITUTION | FRICTION | DENSITY, 0.9,0.9,1.0,1.0);
      llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY,1.0);
      llSetVehicleFloatParam(VEHICLE_ANGULAR_DEFLECTION_TIMESCALE,1.0);
      llSetVehicleFloatParam(VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE,1.0); //Temps pour que le moteur arrive à une vitesse nulle

      llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 5>);
      llSetStatus(STATUS_PHYSICS, TRUE);

      key agent = llGetOwner();
      llRequestPermissions(agentv, PERMISSION_TRIGGER_ANIMATION | PERMISSION_TAKE_CONTROLS);

   }
   touch_start(integer nbr)
   {
       integer lien = llDetectedLinkNumber(0);
       if(lien == reset)
       {
           //Arrêter le véhicule
           llSetStatus(STATUS_PHYSICS, FALSE);
           llSleep(1.0);
           llResetScript();
       }
   }
  run_time_permissions(integer perm)
   {
       if (perm)
       {
           llTakeControls(CONTROL_FWD | CONTROL_BACK | CONTROL_DOWN | CONTROL_UP | CONTROL_RIGHT | 
                           CONTROL_LEFT | CONTROL_ROT_RIGHT | CONTROL_ROT_LEFT |CONTROL_LBUTTON, TRUE, FALSE);
       }
   }
    control(key id, integer level, integer edge)
   {
      if(level & CONTROL_FWD) //Page Haut
       {
           llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <10, 0, 0>); // Ne fonctionne pas dans l'état actuel du script
       }
       if(level & CONTROL_BACK) //Page bas
       {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <-10, 0, 5>); // Ne fonctionne pas dans l'état actuel du script
       }
       if(level & (CONTROL_RIGHT|CONTROL_ROT_RIGHT)) // Flèche droite
       {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, -5, 0>); 
       }
       if(level & (CONTROL_LEFT|CONTROL_ROT_LEFT)) //Flèche gauche 
       {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 5, 0>); 
       }
       if(level & (CONTROL_UP)) //Flèche haut
       {
         llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, 5>);  
       }
       if(level & (CONTROL_DOWN)) //Flèche bas
       {
          llSetVehicleVectorParam(VEHICLE_LINEAR_MOTOR_DIRECTION, <0, 0, -5>);    
       }
       if(level & (CONTROL_LBUTTON)) //Clic gauche souris : arrêter le véhicule
       {
           llSetStatus(STATUS_PHYSICS, FALSE);
           llSleep(1.0);
           llResetScript();
       }
   }

} </syntaxhighlight>

Sources

Récupérée de « https://cogito.no-ip.info/cogito/OSWiki/index.php?title=OpenSim:_Test_Véhicules&oldid=5521 »