Arma: Positionner et assembler des objets

Si tu t’intéresses un peu à la 3D et au positionnement des objets, tu devrais prendre un peu de temps pour lire ce nouvel article. Nous allons voir maintenant comment positionner des objets via scripting et ensuite les assembler entre eux.

Première chose à savoir: le Real Virtual Engine utilise un repère orthonormé main gauche. Le x représente l’horizon, le y la profondeur, le z la hauteur.

Positionner un objet

Pour opérer une translation sur ton objet correctement dans les mondes 3D Real Virtual Engine, tu dois connaitre les différents types de positionnement:

  • ASL – z Relatif au niveau de la mer “Above Sea Level”
  • ATL – z Relatif au niveau du terrain “Above Terrain Level”
  • ASLW – z Relatif au niveau de la mer (vague) “Above Sea Level inc. Waves”
  • AGL – z Relatif au niveau du sol (niveau de la mer quand c’est une position mer, terrain quand c’est une position terrain)
  • AGLS – z Relatif au niveau du sol + surface “Above Generic/Ground Level inc. Surfaces”
  • World – Coordonnée brute du monde – z relatif au niveau de la mer / centre de l’objet
  • Relative – Relatif à la position du modèle de l’objet
  • Config – Position dans le config – z relatif au niveau de la mer

Le positionnement le plus utilisé est le positionnement AGL car il convient à la majeur partie des cas de figure et nous simplifie bien la tâche. Je ne décrirais donc que celui-ci, mais sache que les positionnements ASL & ATL déclinent les mêmes commandes que les commandes AGL indiquées ci-dessous.

Positionnement AGL

Pour positionner un objet, il est crucial de connaitre ces deux commandes: setPos et getPos.

La commande setPos prend en compte trois paramètres [x,y,z].

Exemple

player setpos [5000,5000,0];

Cette commande va donc déplacer le joueur à la position 5000,5000 et qui se trouve à 0 mêtres d’altitude qu’on soit en mer ou sur sol.

Maintenant on va déplacer ton joueur à 2 mètres de haut

player setpos [5000,5000,0];
sleep 2;
player setpos [5000,5000,2];

Dans le Real Virtual Engine, quand tu places ton objet, la masse et la gravité sont appliquées directement. Ton joueur va donc immédiatement tomber de 2 mètres si tu ne le places pas sur un objet. Il est possible de désactiver temporairement la simulation via la commande enableSimulation mais cela bloquera/désactivera toutes les animations de ton objet. Certains objets peuvent également avoir des comportements différents en fonction des collisions et s’ils sont mal placés être projeté dans les airs, ou exploser (tous les composants physx).

Tu peux récupérer la position AGL facilement au format [x,y,z] via la commande getPos.

_position = getPos player;

Le positionnement AGLS

Ici, au format AGLS, le calcul de la position z se fait relativement au sommet de la surface du rocher. Ainsi par défaut, la position z du soldat sur l’image serait de 0. Sache toutefois, qu’il n’existe pas de commande native pour calculer directement ce type de positionnement, il faudra donc utiliser ta propre fonction.

Killzone Kid avait proposé cette fonction assez pratique, pour positionner directement un objet au sommet de la surface d’un objet en fonction de sa position.

KK_fnc_setPosAGLS = {
    params ["_obj", "_pos", "_offset"];
    _offset = _pos select 2;
    if (isNil "_offset") then {_offset = 0};
    _pos set [2, worldSize]; 
    _obj setPosASL _pos;
    _pos set [2, vectorMagnitude (_pos vectorDiff getPosVisual _obj) + _offset];
    _obj setPosASL _pos;
};
//---This will place player exactly on top deck of Cargo HQ on Stratis:
[player, [2437.18,5693.47,0]] call KK_fnc_setPosAGLS;

Rotation d’objet

Nous allons voir comment faire réaliser à ton objet une rotation. Il existe pour se faire 3 commandes setVectorUp, setVectorDir, setVectorDirAndUp. Je ne parlerais ici que de setVectorDirAndUp qui combine les 2 autres commandes. La raison à cela est qu’une erreur de positionnement d’une commande annule le positionnement de l’autre, il est donc préférable d’utiliser la combinée car on a le résultat définitif immédiatement.

La commande setVectorDirAndUp est une commande locale, qui doit être exécutée sur l’ensemble des machines si tu veux qu’elle ai un effet global. Cette commande utilise 2 tableaux de vecteurs en paramètre. Le premier tableau est utilisé pour le vectorDir, le deuxième pour le vectorUp.

Par défaut, l’orientation des objets est toujours le vectorDir qui pointe vers le nord le long de l’axe Y, et le vectorUp qui suit l’axe Z.

vector Dir : [0,1,0]
vector Up: [0,0,1]

Les valeurs de notre repère vont de -1(-90°) à 1(90°). Ce qui correspond donc à ce paramétrage [[0,1,0],[0,0,1]] (équivalent au graphique ci dessous).

Paramétrage: [[0,1,0],[0,0,1]]

Tu vas donc avoir à redéfinir l’orientation de cette brique. Si tu veux par exemple, faire tourner la brique sur l’axe Z de gauche à droite, on a besoin de changer le vectorDir mais laisser le vectorUp inchangé.

//Effectue une rotation sur l'axe Z de 90 degré dans le sens des aiguilles d'une montre.
BRICK setVectorDirAndUp [[1,0,0],[0,0,1]];

//Effectue une rotation sur l'axe Y de 90 dégré dans le sens des aiguilles d'une montre
BRICK setVectorDirAndUp [[0,1,0],[1,0,0]];

//Incline vers l'avant de 90 degré sur l'axe X
BRICK setVectorDirAndUp [[0,0,-1],[0,1,0]];

Si tu fais une erreur, ou que tu utilises un paramétrage créant un conflit, la rotation de l’objet se remet au paramétrage par défaut.

Quelques orientations plus compliquées:

// Inclinaison vers l'avant de 90 et rotation vers la gauche de 90
BRICK setVectorDirAndUp [[1,0,0],[0,1,0]];
// Inclinaison vers l'arrière de 45°
BRICK setVectorDirAndUp [[0,0.5,0.5],[0,-0.5,0.5]];

Comme tu peux le voir, tu peux faire une rotation par degré en changeant simplement le ratio entre les axes. 0.5:0.5 donnera 45 degré. Pour obtenir 30 degré, tu devras utiliser: 0.33:0.66

// inclinaison de 30 degré en avant
BRICK setVectorDirAndUp [[0,0.66,-0.33],[0,0.33,0.66]];

Assembler des objets

Parlons un peu de la commande incontournable attachTo qui permet d’assembler des objets entre eux. Une fois attaché les objets seront solidaires, et bougeront ensemble.

La commande attacheTo utilise les paramètres suivants:

_objToAttach attachTo [_objAttachTo, [_xOffset,_yOffset,_zOffset], _memoryPoint];

Si tu n’utilises par le memory point, ton objet sera attaché par défaut au centre de l’autre objet. Si tu indiques un memory point valide, il sera attaché à ce memory point.

La position d’offset est utilisé pour tuner la position d’attachement de l’objet. La position d’offset est relative au point d’attachement. Les objets ont plusieurs memory points.

Memory points

Les memory points sont des noms définis et placés par les créateurs d’objets 3d au moment de la construction de leurs objets. Les memory points peuvent désigner des lumières, des points sur les véhicules, des points de contrôles pour les animations.

Pour trouver un memory point, il faut ouvrir le modèle de l’objet dans Oxygen 2 et sélectionner les memory LOD. Cela te donnera accès à la liste complète des memory points pour l’objet en question, la plus part de ceux-ci fonctionneront avec la commande attachTo.

Les modèles d’exemple d’Arma3 utilisent les memory points suivants (déclarés dans Memory Lod):

aiming_axis, aimPoint, BubblesDir, BubblesEffect, camera, footstepL, footstepR, granat, granat2, Head, head_axis, lankle, launcher, leaning_axis, LeftFoot, LeftForeArm, LeftForeArmRoll, LeftHand, LeftHandMiddle1, LeftShoulder, lelbow, lelbow_axis, lfemur, lknee, lknee_axis, lwrist, Neck, Pelvis, pilot, rankle, rearm, rearm2, relbow, relbow_axis, rfemur, RightFoot, RightForeArm, RightForeArmRoll, RightHand, RightHandMiddle1, RightShoulder, rknee, rknee_axis, rwrist, Spine3, water_surface, Weapon

Pour l’exemple concernant le C4 (tout en bas de cet article), j’ai utilisé un memory point qui s’appelle « pelvis » avec quelques tunings de l’offset pour le positionnement du C4.

Orientation avec AttachTo

Attacher un objet à un autre objet va placer l’objet dans une orientation par défaut qui ne sera pas forcement celle désirée. Car, quand tu attaches un objet à un autre objet, l’axe devient relatif à l’objet attaché. S’il s’agit par exemple d’un objet player , alors l’axe X va de gauche à droite, le Y de derrière à devant, le Z de bas en haut.

Finalement, voici le code tant attendu, pour attacher 3 bâtons de C4 à un joueur en utilisant l’attachement, et les orientations correctes.

_expl1 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl1 attachTo [player, [-0.1,0.1,0.15],"Pelvis"];
_expl1 setVectorDirAndUp [[0.5,0.5,0],[-0.5,0.5,0]];
_expl2 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl2 attachTo [player, [0,0.15,0.15],"Pelvis"];
_expl2 setVectorDirAndUp [[1,0,0],[0,1,0]];
_expl3 = "DemoCharge_Remote_Ammo" createVehicle (position player);
_expl3 attachTo [player, [0.1,0.1,0.15],"Pelvis"];
_expl3 setVectorDirAndUp [[0.5,-0.5,0],[0.5,0.5,0]];

Pour détacher les objets, il faudra utiliser la commande detach. Cela est tout pour ce mini tuto 🙂

Cet article a été initialement rédigé par Killzone Kid, complètement revu, et corrigé par Code34

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s