Tutoz

Voici un tutoriel qui vous explique une méthode pour paramétrer au mieux un squelette de bras dans XSI à fin d'avoir un maximum de possibilité pour animer ce dernier.

Ce qu'il faut retenir principalement c'est la façon d'arriver au résultat voulu. Pour cela il faut déterminer ce que nous voulons et dans quel but. Puis trouver les solutions efficaces et ergonomiques pour y parvenir. Et enfin trouver les astuce pour faire fonctionner le système pour que l'animateur puisse faire un maximum de mouvement tout en aillant un accès le plus claire possibles aux réglages.

Quand vous paramétrez un personnage, il est facile d'imaginer toute les choses qu'il est possible de faire et comment il est simple de manipuler et de transformer. Durant le Rigging, beaucoup de ces idées s'envolent à cause des contraintes de planning et/ou des difficultés techniques. L'une des choses qu'un animateur rêve de pouvoir faire, c'est de pouvoir animer l'étirement et l'écrasement (squash & stretch), une technique classique de l'animation qui est souvent mis de coté par les professionnels du paramétrage 3D. Bien sûr, le Principe du squash & stretch peut être mis en œuvre dans les poses du personnage et dans le comportement de ses extrémités, mais voyons comment la liste de souhait si dessous peut être mise en œuvre dans le Rigging fonctionnel d'un bras et dont le contrôle du squash & stretch est facile et rapide :

• Capacité à déformer (S&S) une chaîne et de pouvoir mettre ce comportement On/Off
• Capacité à réinitialiser n'importe quelle taille (S&S) sans changer la posture (le long de l'axe Effecteur/root)
• Capacité à déformer l'avant bras et le bras individuellement ou les deux ensemble (Effecteur reste en place)
• Permettre au volume du bras de changer et de pouvoir mettre ce comportement On/Off
• Pouvoir sélectionner manuellement la partie déformable et animable de la main
• Placer le coude dans n'importe quel direction (indépendamment du reste de la chaîne, pour l'ajustement de la pose finale et la capacité de casser les articulations comme décrit dans « The animator's survival kit »)
• Passer à une cinématique inversée ou à une cinématique normale (personnaliser une excellente capacité au changement du FK/IK pour le Rigging)
• Pouvoir rapidement verrouiller la position d'une main pendant l'animation (pour la poser sur une table par exemple...)
• Prévoir une rotation divisée au niveau de l'avant bras pour bien gérer les déformations du maillage à cet endroit.

Image 1 – Le Rigging complet et finalisé

• 1. Créez une chaîne avec 2 os dans la vue de Droite et appelez la racine « r_arm », et les os « b_upArm » et « b_loArm » et l'Effecteur « e_arm ». Ce nommage va vous permettre de bien suivre ce tutoriel et de retrouver rapidement vos éléments grâce au MCP (Main Command Panel), utilisez « b_* » etc...
• 2. Dans la fenêtre des propriétés générales de ces os, mettez la longueur du bras sur « 3 » et celle de l'avant bras sur « 4 », pour être sure de travailler avec des chiffres ronds (mais être capable de les distinguer l'un de l'autre).
  En changeant les valeurs des ces longueurs, le bras peut être étiré – ou encore reprendre sa taille d'origine. Ces changements dépendront de la position des Effecteurs, ou mieux : de la distance entre l'Effecteur et la Racine de la chaîne.
  Cette distance peut être mesuré via une expression et être utilisé pour paramétrer la taille des os.
  Pour garder une certaine lisibilité, il serait utile de créer un objet à part qui garderait cette information de distance.
• 3. Créez un objet Null et nommez le « dist » pour mesurer et en même temps afficher la distance être l'Effecteur et la Racine du bras.
  
• 4. Mettez une Expression dans la Translation locale Y de l'objet Null (kine.local.posy), saisissez l'expression suivante :
  ctr_dist(r_arm.kine.global.pos, e_arm.kine.global.pos) et appliquez la (en cliquant sur « Apply ») Maintenant, quand vous déplacez le Effecteur, le « dist » bougera sur son axe Y (vous pouvez un peu le déplacer sur l'axe Z) de la même valeur que la distance entre la racine du bras et l'Effecteur.
• 5. Appliquez une Expression sur la longueur du bras, qui lui dira que si la distance avec l'Effecteur est plus grande que la somme des longueurs originales des deux os (donc un bras tendu), l'os s'étire (pour s'approcher de l'Effecteur). La somme des longueurs originales des os (3-4=7) sera donc la longueur du bras. Cond(dist.kine.local.posy > 7 , 3 + (dist.kine.local.posy - 7) / 2 , 3) cela veut dire : quand (la distance est plus grande que la longueur du bras alors, la longueur de l'os courant est égale a sa valeur d'origine + le reste de la distance actuelle (dist) moins la longueur du bras (dist – (3+4)).
• 6. Appliquez la même expression pour la longueur de l'avant bras, prenez en compte que sa longueur d'origine est 4 et non 3 comme le bras.
  Cond(dist.kine.local.posy > 7, 4 + (dist.kine.local.posy – 7) / 2, 4) Maintenant l'Effecteur peut être tiré d'autant que vous le voulez et les os s'étireront en fonction de et se compresseront jusqu'à leur taille originales et se comporteront normalement.


Image 2 – Étirement de la chaîne du bras

Quand vous aurez fait ça, trois nouveaux besoins se présentent :

1. Capacité à verrouiller le comportement normal d'une chaîne avec sa taille originale.
2. Capacité à plier le bras tout en étant sur étiré.
3. Capacité à écraser le bras de manière plus petite que sa taille originale.

Comme il serait préférable de verrouiller n'importe quelle animation avec un « Verrou », taille des os fixes et animer celle-ci plus tard, la capacité de désactiver la déformation de la chaîne est importante.
De même, quand vous faite une pose à votre personnage, il serait bien de pouvoir réinitialiser les accidentels sur-étirements, ce qui remettrait le bras à sa taille originale tout en gardant la pose (le long de l'axe Effecteur/Racine).
Une condition dans l'Expression de la longueur des os peut prendre en compte ça : seulement autoriser à changer la longueur des os quand le nouveau paramètre reset-and-lock est égal à 0. Comme la longueur des os tient compte de la mesure de la distance, il est plus simple de faire ça pour contrôler le comportement des os.

• 7. Créez un autre Objet Null (« resetAndLock ») et..
• 8. Changez l'Expression de l'objet « dist » comme suit :
  cond( resetAndLock.kine.local.posy == 0, ctr_dist(r_arm.kine.global.pos, e_arm.kine.global.pos ), 7 ) cela à pour cause que « dist » mesure la distance entre la r_arm et e_arm uniquement quand « resetAndLock » est égale à 0. Pour toute autre valeur, la distance est de « 7 », la distance est égale à la longueur du bras – du coup, on retrouve notre chaîne originale créée au part avant.
  

  
  Image 3 – Editeur d'Expressions

A part réinitialiser et verrouiller l'étirement d'une chaîne, il serait bien de pouvoir distinguer l'étirement de chaque os séparément, ou ensemble, ou les 2 en même temps – même avec l'Effecteur fixé sur sa position. Prenez note que ces compensations de longueur pourraient également fonctionner pendant que la chaîne est déjà étiré et pliée. Et elles pourraient nous apporter la capacité a animer à la main l'écrasement des os dont nous avions besoin. Tout cela sera contrôlé par 3 paramètres, respectivement les paramètres de Compensation :

1. du bras
2. de l'avant bras
3. des deux os

• 9. Créez 3 Nulls qui fourniront ces paramètres (« stretchUp », « stretch » et « stretchLo »). Maintenant, l'échelle sera utilisée pour gérer l'étirement des os. La valeur de l'échelle sera simplement ajouter à l'Expression de longueur des os.
• 10. Éditez l'Expression de la longueur de b_upArm
  avant : cond( dist.kine.local.posy > 7, 3 + ( dist.kine.local.posy - 7 ) / 2, 3 ) après : cond( dist.kine.local.posy > 7, 3 + ( dist.kine.local.posy - 7 ) / 2, 3 ) + stretch.kine.local.sclx + stretchUp.kine.local.sclx - 2 Le « -2 » est pour compenser la valeur initiale du contrôleur (qui était 1), donc, une échelle de « 1 » veut dire « pas de compensation » (0)
• 11. Faites la même chose avec la longueur du b_loArm (rappelez vous que sa longueur d'origine est différente) cond( dist.kine.local.posy > 7, 4 + ( dist.kine.local.posy - 7 ) / 2, 4 ) + stretch.kine.local.sclx + stretchLo.kine.local.sclx - 2
  Mais maintenant l'Effecteur suivra encore les os, comme il n'est pas encore contraint par les objet de contrôle.
• 12. Placez un nouveau Null (« c_arm ») au même endroit que l'Effecteur et appliquez une contrainte de Position de l'Effecteur vers le nouveau Null.

  
  Image 4: Gestion de l'étirement individuel des os

Maintenant, il y a énormément d'objet Null sur la scène, pour aider les Expressions. Bien sûr, ces Expressions sont référé à différents paramètre d'un seul Null, ou un paramètre personnalisé, avec les paramètres nécessaires stocké dedans (soyez conscient que XSI n'aime pas trop les CustomPSet avec certains paramètres qui sont stockés dans une objet de chaîne – Il renvoi une erreur de cycle de dépendance).

Et aussi, toutes les Expressions pourraient être piloté par un objet contrôleur présent du Rig du Personnage, qui implémenterait toutes les fonctionnalités présentés clairement dans une vue 3D, lequel serait idéal pour un animateur. Cependant, il est conseillé d'utiliser de Objet Null Séparés pour bien tout paramétrer, comme ils nous donnent une bonne vue d'ensemble et sont facile à retrouver au cas où il y a des problèmes ou un comportement non désiré.

Voyons une partie différente, un contrôleur suivit par le coude et qui peut corriger l'orientation de celui ci par une simple translation. La racine du bras et l'Effecteur reste en place, mais le coude peut être bougé librement a une position voulu et dans n'importe quelle direction – il est donc très différent d'un upvector constraint.

Cette spécification est utilisé pour perfectionner une pose que l'on voudrait ajuster un peu mieux si le coude est placé de manière anatomiquement incorrect, au cas où, sur quelques frames.
Dans le légendaire livre de Richard Williams, « The Animator's Survival Kit », il parle souvent de « breaking » (cassure) une articulation pour affiner une animation. Avec ce correcteur d'orientation du coude, il peut plus facilement être réalisable en 3D.

Pour faire ça, une seconde chaîne sera créé pour suivre la chaîne originale. C'est en réalité 2 chaînes composées de 1 os plutôt qu'une simple chaîne de 2 os, et cela pour simuler le comportement du bras définie par le correcteur d'orientation du coude.

• 13. Créez un Null de contrôle du coude (« c_elbow ») et faite correspondre sa position avec l'os b_loArm.
• 14. Placez le comme enfant de l'os b_loArm, comme ça il restera toujours au niveau du coude, et il peut facilement être animé d'ici.
• 15. Dessinez 2 chaînes de 1 os exactement comme les 2 os originaux du bras. Il serait mieux d'utiliser l'outil de magnétisme avec les centres. Nommez les (« r_offsetUp », « b_offsetUp », « e_offsetUp ») et (« r_offsetLo », « b_offsetLo », « e_offsetLo »).
• 16. Placez une contrainte de Position sur le premier nouvel os sur la racine original « r_arm » et le Contrôleur d'orientation du coude, et le second nouvel os au contrôleur d'orientation du coude et l'Effecteur original. Comme ceci:
  1. r_offsetUp -> r_arm
  2. e_offsetUp -> c_elbow
  3. r_offsetLo -> c_elbow
  4. e_offsetLo -> e_arm

  
  Image 5 – contrôle de l'orientation du coude

• 17. Cachez les nouvelles racines et Effecteurs pour avoir une bonne lisibilité. Vous pouvez voir que le contrôleur d'orientation du coude fonctionne toujours, et il peut facilement être réinitialisé à 0 en pressant Ctrl+Shift+R. Mais les nouveaux os doivent ajuster leurs longueurs proportionnellement, comme le maillage sera enveloppé (skinné) à lui plus tard (pour suivre le contrôleur d'orientation du coude). On peut très bien juste faire comme précédemment, utiliser la distance entre le contrôleur du coude et la racine du bras original, etc...
• 18. Appliquez les Expressions suivante

  b_offsetUp.bone.length:
  ctr_dist( r_arm.kine.global.pos, c_elbow.kine.global.pos ) b_offsetLo.bone.length:
  ctr_dist( e_arm.kine.global.pos, c_elbow.kine.global.pos )

  Voilà, c'est bien mieux mais quand vous faite un upVector sur votre chaîne originale, vous noterez que les nouveaux os ne suivent pas la rotation X des os originaux. C'est facile de remédier à ça avec l'os offsetLo.
• 19. Créez un objet Null (« c_upVec »). select b_upArm et appliquez lui le upVector Create>Skeleton>ChainUpVector. Déplacez quelque peu le c_upVec pour voir le problème de rotation avec les nouvelles chaînes offset. Au lieu de contraindre la position de r_offsetLo à celle de c_elbow, utilisez une contrainte de pose pour prendre en compte la rotation également.
• 20. Supprimez le position constraint de r_offsetLo et appliquez lui un pose contraint sur c_elbow. Maintenant il aura toujours la même rotation que l'os original de l'avant bras. Pour l'os offset du bras ce n'est pas si simple, mais laissons cela de coté pour le moment une solution plus pratique viendra plus tard lors de la procédure. Avant changer de partie, mettez comme enfant la plus ressente chaîne créée dans la racine du bras r_arm juste pour nettoyer un peu.
• 21. Glissez et relâchez avec le bouton centrale de la souris r_offsetLo et r_offsetUp dans r_arm

Maintenant, quand vous étirez la chaîne, l'enveloppe du bras devrait suivre et grandir, mais il ne conserve pas vraiment son volume, il garde la même épaisseur – à moins que les axes Y et Z des os soient réduit proportionnellement pendant que la longueur de celui ci augmente.

• 22. Appliquez une Expression de mise à l'échelle de l'axe Y sur le bras – l'os b_offsetUp, comme le bras sera enveloppé(skinné) par les os de l'offset. Pour avoir une indirect relation de proportion entre la longueur et l'échelle, l'échelle sera : un divisée par les longueurs de l'os. (1 / longueur de l'os) ou : (1 / ( b_offsetUp.bone.length - 2)) Quand la chaîne n'est pas étirée, l'échelle des os devra être 1. Ce qui correspond au résultat d'un « 1/1 ». Donc 1 sera divisé par la longueur de l'os original -2.
• 23. Mettez la même Expression sur le paramètre SclZ. Ne glissez pas juste l'Expression du paramètre SclY sur le paramètre SclZ, car XSI vous renvoi une erreur de cycle de dépendance. Maintenant le bras conserve son volume quand il est étiré. Quand on anime, vous trouverez qu'il n'est pas toujours bien d'avoir une conservation du volume lors de l'étirement, Il serait donc intéressant de désactiver cette effet, ou de corriger ça manuellement.
• 24. Créez un Null (« volScale ») et utilisez sa Position y locale pour mettre l'effet de maintient du volume On ou Off.
• 25. Changez l'Expression du SclY du bras et désactivé l'effet de maintient du volume en configurant le volScale sur y=0. cond( volScale.kine.local.posy == 0, 1, 1 / ( b_offsetUp.bone.length - 2 ) )
• 26. Utilisez la translation X de ce même volScale pour gérer le maintient du volume manuellement, et donc avoir la possibilité de tricher, tricher et tricher... cond( volScale.kine.local.posy == 0, 1, 1 / ( b_offsetUp.bone.length - 2 ) + volScale.kine.local.posx )
• 27. Appliquez le même changement de script à SclZ.
• 28. Et faites la même procedure pour l'avant bras b_offsetLo (SclY et SclZ) cond( volScale.kine.local.posy == 0, 1, 1 / ( b_offsetLo.bone.length - 3 ) + volScale.kine.local.posx)

Nous allons rapidement configurer une chaîne pour le poignet et penser à comment faire au mieux pour contrôler celui ci lors de l'animation. Il y a 2 principes de base :
-soit la rotation du poignet suit l'Effecteur du bras, et donc la main est toujours alignée sur l'avant bras quand vous bougez le bras.
-soit la rotation du poignet est conservée et ce dernier fixé dans l'espace quand vous bougez le bras, et dans ce cas, il est toujours orienté dans la même direction et ne suit pas l'orientation de l'avant bras.

Ces 2 méthodes ont leurs avantages et leurs inconvénients. Quand vous faites des poses à votre personnage, ou que vous faites un mouvement du bras, il est plus naturel que le poignet suive l'avant bras, et toutes les animations additionnelles seront facile à contrôler avec les F-curves, comme nous le savons sa rotation est toujours de 0, 0, 0 par rapport au bras.

Cependant, ce comportement n'est pas le bienvenue quand le bras est animé et ses upVector ajustés après (l'ensemble de l'animation de la main va changer avec ça) ou si il y a une interaction avec d'autres objet dans la scène (quand il faut soulever un objet par exemple).

Toutefois, pour avoir le meilleur des 2 possibilités, nous allons essayer et réussir a configurer un controleur de poignet qui peut gérer les 2 solutions, et l'animateur pourra passer d'un comportement à l'autre.

• 29. Dessinez une chaînes avec un os dans la vue de droite et nommez les nouveaux objets (« r_wrist », « b_wrist », « e_wrist »)
• 30. Faites correspondre la rotation du « r_wrist » avec l'Effecteur « e_arm », et mettre à 0 les rotations de l'os « b_wrist », de sorte que sa rotation Z s'oriente vers la main et le corps, avec le bras dans sa pose naturel de base.
• 31. Dupliquez le contrôleur c_arm (« c_wrist ») et mettez le une peu plus petit. Il contrôlera la rotation de la main.
• 32. Créé un Null (« wristBuffer »), et faites correspondre sa translation au contrôleur « c_wrist » et sa rotation à l'Effecteur « e_arm ».
• 33. Mettez comme enfant le contrôleur « c_wrist » dans « wristBuffer » et mettez toutes les rotations à 0.
• 34. Mettez une contrainte d'orientation à l'os b_wrist au contrôleur « c_wrist ».
• 35. Mettez une contrainte de Position sur « r_wrist » à l'Effecteur « e_arm ».
• 36. Mettez une contrainte de Position sur « wristBuffer » à l'Effecteur « e_arm ».
• 37. Bien, maintenant mettez une contrainte d'orientation au « wristBuffer » à l'Effecteur « e_arm » et verrouillez les contraintes du Panneau des propriétés générales (PPG). Ses drapeaux actifs seront utilisé pour passer d'un comportement à l'autre – soit l'objet de contrôle (et donc le poignet) suivra l'orientation des Effecteurs ou non.
• 38. Liez l'activation de la contrainte au paramètre SclX du contrôleur « c_wrist », pour être capable d'alterner les comportements directement dans le Viewport (interface). cond( c_wrist.kine.local.sclx < 1, 0, 1)
Jouez avec et voyez si cette configuration vous plaît. Il est assez confortable de créer rapidement des poses à votre personnage avec le poignet qui suit le bras et capable d'avoir un comportement différent et ainsi de ne plus suivre ce dernier et d'avoir la possibilité de garder la simplicité du F-curves pour gérer les rotations de l'Effecteur.


Image 6 – Configuration du poignet

Note : Prenez conscience que ce poignet peut causer des blocages de cardan (gimbal Lock) durant l'animation. Vous pouvez essayer un ordre différent d'axe de rotation dans les propriétés de la cinématique de votre os du poignet (YZX marchent bien pour moi), ou suivre d'autres tutoriels sur comment contourner le problème du Gimbal Lock – comme la méthode de séparer les axes de rotation sur différents objets de contrôle.

Un autre truc est qu'il arrive toujours, pendant une animation, d'avoir besoin de pouvoir rapidement bloquer une main à un endroit, quand vous la posez sur une table par exemple. Ceci est possible avec la contrainte de Position sur le contrôleur du bras et la contrainte d'orientation sur le contrôleur du poignet.

• 39. Créez un objet Null auquel le bras et la main pourront s'encrer (« handSnap »). Il devra donner un signal visuel que la main utilisera pour se contraindre.
• 40. Mémorisez les coordonnées de translation de « c_arm »
• 41. Placez une contrainte de Position sur « c_arm » par rapport à « handSnap »
• 42. Mettez l'Expression suivante sur le paramètre « active » de la contrainte de position cond( c_arm.kine.local.scly < 1, 1, 0 ) cela utilisera l'échelle du contrôleur qui permet de passer d'un comportement à l'autre. Quand « c_arm » est mis à l'échelle sur Y, le bras ce magnétise sur le « handSnap » et reste fixé dessus. Allons faire la même chose pour l'orientation de la main.
• 43. Placez une contrainte d'orientation à « c_wrist » par rapport à « handSnap », puis remettez les coordonnées de Translation mémorisées à « c_arm »
• 44. Collez la même Expression sur le paramètre « active » de la contrainte d'orientation
cond( c_wrist.kine.local.scly < 1, 1, 0 ) En animant l'échelle, les 2 contraintes peuvent être paramétrées indépendamment, selon la situation de la main. Mais aussi, les paramétrages des contraintes sont encore accessible et animable, libre à l'animateur de mélanger ces paramètres autant qu'il lui est nécessaire.

Il faut placer le « handSnap » dans un endroit efficace – un endroit qui ne gène pas l'animation mais qui reste facilement accessible lorsque l'on anime. Il pourrait suivre l'ensemble du bras par sa racine « r_arm », avec les autres objets, ceux qui contrôlent pleins de paramètres que nous avons configuré précédemment (voir le prochain paragraphe).

Il y a énormément de fonctionnalités et différentes options dans ce paramétrage de bras maintenant, il pourrait amener l'animateur à confusion. Il est donc conseillé de faire quelque chose pour nettoyer un peu tout ça, afin de fournir l'information de manière claire et avoir la possibilité d'avoir un retour de ce qui se passe sur le moment.
Ajouter des annotations pour appeler les objets de contrôle qui ont des fonctions spéciales, par exemple quand vous modifiez l'échelle Y.

• 45. Sélectionnez « c-arm » et appliquez Get>Property>Annotation.
• 46. Écrivez, par exemple, « sclY < 1 active la contrainte de POSITION de handSnap ». Faites la même chose pour tous les contrôleurs qui portent a confusion ou qui ne sont pas claire. La propriété d'annotation peut être lu à n'importe quel moment quand l'objet est sélectionné, cliquez juste sur « selection » dans le MCP ou regardez dans le selection-mode de votre explorer – vous trouverez l'icône rougeâtre de l'annotation.
  Une autre façon simple de ranger vos contrôleurs est de changer leur couleur ou ceux des os quand vous les étirez. Ceci est possible par une Expression qui agit sur la couleur d'affichage de l'objet, et de dire : « quand il est plus grand que 1, change-toi en rouge » par exemple.
• 47. Sélectionnez « b_upArm » et isolez le dans l'explorer. Remarquez comment les paramètres de « Display » sont écrit en Italique, cela veut dire qu'ils sont partagés avec le reste de la scène et vous avez besoin de les rendre local avant de procéder à la moindre modification.
• 48. Cliquez sur l'icône « Display » et dans la boite de dialogue, appuyez sur « Yes » (pour le rendre local). Maintenant, « Display » n'est plus écrit en Italique.
• 49. Déployez l'arborescence des options d'affichage (Display) dans la fenêtre d'explorer et mettez une Expression sur la propriété « colour » cond( b_upArm.bone.length > 3, 15, 0 ) « 15 » est le joli rouge éclatant, donc à chaque fois que l'os est plus grand que sa taille d'origine, sa couleur passera au rouge. Cela pourrait être encore mieux pour gérer les contrôleurs d'étirement, pour être capable de voir si il y a un étirement d'appliqué ou non. Cela pourrait donc être encore mieux pour le passage au rouge. Quand l'os est plus grand OU plus petit que 1 (« != » est la commande d'Expression pour dire « différent de » - regardez dans « Function>Conditions » dans l'éditeur d'Expression pour plus d'informations). Peut être que l'on pourrait le configurer avec 2 conditions : « devient au rouge quand plus grand que 1,1 ou plus petit que 0,9, pour avoir un peu de marge entre les 2 – comme ça il sera facile de trouver le point zero quand on travail manuellement.
• 50. Pour la gestion de l'os du coude il serait intéressant qu'il soit visible uniquement quand le coude est en cours de correction. Appliquez une Expression sur sa visibilité :
  cond( c_offset_l_arm.kine.local.posx == 0 && c_offset_l_arm.kine.local.posy == 0 && c_offset_l_arm.kine.local.posz == 0, 0, 1 ) et on pourrait peut être que changer sa couleur en jaune vif (« 126 ») pour être toujours capable de voir ce dernier (Regarder l'historique de votre éditeur de script et trouvez la valeur exacte de couleur que vous désirez).
  Et enfin la dernière chose et non la moindre, quand le Rig fonctionne correctement comme vous le voulez, simplifiez le en vous débarrassant doucement de tous ces contrôleurs/Nulls et remplacez les par des contrôleurs plus visuel, implanté dans le Rig. Ça prendra un certain temps pour rééditer toutes les Expressions pour pouvoir travailler avec ces nouveaux objets, mais cela vous facilitera bien la tâche quand vous animez.

  
  Image 7 – Icônes des contrôleurs de la chaîne

Un autre point important c'est la décision à prendre quand vous animez un bras et spécialement savoir si vous devez utiliser le FK ou le IK. Maintenant, ce bras est évidement prévu pour de l'IK, mais avec l'excellente implantation du mixage FK/IK dans XSI, ça serait honteux de ne pas ajuster notre Rig afin qu'il soit capable de tirer partie de ses spécifications.

Vous pourrez trouver les contrôleurs FK/IK d'XSI dans les « Kinematic Chain Properties » sous le PREMIER os de la chaîne. L'interrupteur FK/IK permet effectivement de jouer entre les 2 méthodes d'animation.
La seule chose qui prévoit le passage au mode FK sur notre bras est la contrainte de Position appliqué à l'Effecteur « c_arm ». Cependant, si nous contrôlons l'activité de cette contrainte de Position avec une Expression, il peut aussi, par exemple être désactiver par un changement d'échelle de notre c_arm, et en même temps utiliser le contrôleur FK/IK pour dire à XSI quand il faut passer en mode Chaîne FK.

• 51. Appliquez une Expression au mixeur de la contrainte de position de l'Effecteur « e_arm » c_arm.kine.local.sclx
• 52. Appliquez la même expression sur le mixeur de la propriété FK/IK de la « Kinematic Chain properties ». Maintenant, chaque fois que le contrôleur c_arm à son échelle qui réduit sur l'axe X, XSI passera du mode IK en mode FK, et l'efficacité de la contrainte de Position sera que d'autant proportionnellement plus faible, jusqu'à ce que – x_scale = 0 – le système suivra les cinématiques.
  Animez simplement l'échelle pour changer l'état du IK/FK et vice versa!
  Changer l'échelle du contrôleur et regardez en même temps le comportement, mais nous allons également avoir besoin d'utiliser l'icône de contrôle des os du bras, donc ils pourraient être facilement de les attraper quand on anime en mode FK (ceux ci peuvent très bien être contrôlé par des Expressions et ainsi seulement apparaître quand on est en mode FK)

Pour finir le Rigging de notre bras, quelques équilibrages de nos contrôleurs s'imposent. Habituellement, il peut être très fastidieux de bien équilibrer les avant-bras pour avoir une belle rotation au niveau du poignet lors de sa rotation sur X. Ceci est dû à l'algorithme naturel de l'enveloppe du bras qui ne s'interpole pas avec la rotation de l'enveloppe osseuse.
Il y a de nombreuses approches différentes sur comment contourner le problème, avec un second os le long ou pas de l'avant bras, pour bien penser à faire un rigging anatomiquement correct de la structure de l'avant bras. Cependant, dans ce tutoriel, les contrôleurs seront positionnés le long de l'avant bras, pour amortir la rotation du poignet par rapport a l'orientation du coude.
Le même problème s'applique pour le bras et son comportement arrive quand il est tourné sur l'axe X.
La partie proche des épaules reste quasiment en place, mais la partie proche du coude tourne plus en suivant la rotation de l'os. La même approche peut être utilisé ici.

Ces contrôleurs sont habituellement appelez « roll divisions », et peuvent être créé automatiquement avec les rigs intégrés à XSI. C'est vraiment génial, au passage, tout est paramétré avec des opérations codées super rapides qui font tout ce qu'il faut et ce qu'il ne faut pas, assurez vous de les tester.

Maintenant nous allons paramétrer manuellement ces « rolls divisions » (séparateurs de torsion) juste pour le fun.

Quand on fait la symétrie du rigging du bras, sur une autre partie du personnage, soyez sûre que les « freeze negative scaling » dans la boite de dialogue de Skeleton>DuplicateSymmetry est sur Off. Vous voulez dupliquer les contraints, et parfois, il se passe que les contrôleurs se magnétise à une position indésirable. Dans ce cas, réinitialisez simplement en remettant les coordonnées 0.
Je dis ça, évidemment, je suppose que les contrôleurs sont par défaut sur la position 0. Vous pouvez faire ça facilement en sélectionnant Create>Skeleton>SetNeutralPose pour chaque contrôleur. Et aussi, soyez sûre de bien ajuster les Expressions des contrôleurs de séparation de torsion pour que ça fonctionne correctement sur la copie symétrique (exemple : mettez les à « - rotation du poignet / 2 »...etc...)

Observez, cela demande peu de travail de transformer notre chaîne avec cette configuration. Cela peut prendre un peu de temps pour disons, les deux bras et les deux jambes d'un personnage – surtout quand on à besoin de déplacer, tourner ou ajuster les tailles de la chaîne. Il faut également réajuster toutes les Expressions pour la longueur des os, la distance réelle...etc...- assez fastidieux.
Pour éviter ça, assurez-vous que la position des os est définitive, ou utilisez un script pour automatiser un peu le processus.

Nous avons désormais terminé un rigging assez avancé d'un bras de personnage. Il est spécialement adapté aux besoins des animateurs et est capable de combler beaucoup de leurs besoins. Naturellement, différents animateurs préfère différents rigs ou différentes approches, mais j'espère que ce tutoriel vous a donné assez d'information ou idées pour devenir un spécialiste des contrôles de mouvement de bras.

N'hésitez pas à me faire part de vos remarques pour améliorer cette page d'aide. Je remercie Christoph Schinko qui a rédigé ce tutoriel en 2006 que j'ai traduit et adapté en français.

Christoph Schinko - Animateur de personnage et créateur de film indépendants, et est un instructeur certifié XSI depuis plus de 5 ans. Vous pouvez lui écrire (en anglais) à : stoph[@]christoph-schinko.com