---
# System prepended metadata

title: '**Wiki** Rig Personnages'
tags: [DashBoard, Notice, Rig]

---

[:arrow_left:](/WQum2tYYSXGaBjnU2wMxzQ) To Pirata Dashboard
[:arrow_left:](/yy71c8NjRiykh_DA-SYOiQ) To Rig Dashboard


# **Wiki** Rig Personnages

###### tags: `Rig` `Notice` `DashBoard`

:::warning
**NAMMING:**
Side_NamePadding dans les Namespaces
Side_Name_Padding_Extra_Type
:::
## **1.** **PLACER LE RIG WORLD (voir HackMD Rig World: https://hackmd.io/7GQgZRxeQf2nno8OCJyDiw?view)**


## **2.** **RIG ADDITIONNEL**

:::info
Cette étape se fera dans la Task "Rigging" et consiste à positionner et connecter les modules qui vont monter le Rig du personnage, nous allons procéder par étapes: jambes, bras, mains, spine, et rig additionnel pour les vêtements et accessoires. 
:::
* On vient ouvrir le InRigging et on FileSave en Rigging.
![](https://i.imgur.com/5uN15Es.png)
![](https://i.imgur.com/PZtqZft.png)
* On UnBind le skin des meshs.
 
### **LA SPINE**
* Dans le Loader on load en référence la **Spine01_Classic** et on renomme son Namespace (ici **C_Spine01**).
* On la place avec les groupes de **Pos** dans **Input**, d'abord le premier et ensuite en sélectionnant les deux autres pour garder un équart égal entre chaque joint et on vient ajuster si besoin.
:::warning
Quand on place les modules de Rig, on fait toujours bien attention à l'orientation des joints! Pour voir les axes on sélectionne les joints et on fait `Display:Transform` `Display:Local Rotation Axes`
:::
* On peut gérer la taille des contrôleurs dans le **Trash_Grp**.
:::info
On va avoir besoin de deux Ribbons, un 01 et un 02, le 02 (qui n'est pas complet et sert juste à l'assemblage) va être celui du bas de la Spine sur lequel on va accrocher le 01 qui va faire partie de la deuxième partie de la Spine. 
:::
* On regarde le nombre d'Edges entre le premier et le deuxième joint de la Spine et on Load le **Ribbon02_Classic** correspondant .
* On renomme son Namespace (**C_Spine01Rib01**).
* On le place grâce aux groupes **Pos** dans **Input_Grp**, le **Bot** sur le premier joint de la Spine et le **Top** sur le joint du milieu de la Spine.

![](https://i.imgur.com/1qsLoEl.png)


* On regarde le nombre d'Edges entre le deuxième et le troisième joint de la Spine et on Load le Ribbon01_Classic correspondant .
* On renomme son Namespace (**C_Spine01Rib02**).
* On le place grace aux groupes Pos dans Input_Grp, le Bot sur le deuxième joint de la Spine et le Top sur le dernier de la Spine.

![](https://i.imgur.com/M6KRjsb.png)


* On peut gérer la taille des contrôleurs avec les **Trash_Grp** des Ribbons (du plus petit au plus grand : *Ribbon < BezierHandle < BezierMaster < CtrlFk* de la Spine).
![](https://i.imgur.com/uD4JoqU.png)

:::info
Il faut maintenant connecter les Ribbons à la Spine pour qu'ils soient entrainés par celle-ci mais aussi relier les deux Ribbons entre eux. 
:::
* Pour commencer on va connecter les deux Ribbons :
On prend le **_A_Ctrl** du **Rib02** et le **_B_Hook** du **Rib01** et on vient connecter leurs attributs Bezier Handle.
On crée un node decomposeMatrix nommé "**C_Spine01Rib02_ACtrlRibAsb_Dcm**",
on fait une connexion `Matrix -> InputMatrix`.
Enfin, on connecte les **output** du decomposeMatrix sur le **B_Hook** en translate, rotate et scale.
![](https://i.imgur.com/pV9Ecuk.png)

* On prend ensuite le **C_Spine01Rib02:_Bot_Pos** du Rib02 et **C_Spine01Rib01:_Top_Pos** du Rib01 (dans Input) et on fait une Contrainte Parent sans maintain offset, que l'on nomme **C_Spine01Rib01_TopPos_Pac**
![](https://i.imgur.com/9b8dxfM.png)

* On va maintenant relier la Spine au Ribbon, dans le Grp **Output_Grp** de la Spine on a les joints.
* On fait une Contrainte Parent (sans maintain offset) du premier joint de la Spine **C_Spine01:_01_Out** sur le **C_Spine01Rib01:_Bot_Pos** du Rib01, que l'on nomme **C_Spine01Rib01_BotPos_Pac**.
* Une Contrainte Parent (sans maintain offset) du troisième joint de la Spine **C_Spine01:_03_Out** sur le **C_Spine01Rib02:_Top_Pos** du Rib02, que l'on nomme **C_Spine01Rib02_TopPos_Pac**.
* Une Contrainte Point du deuxième joint de la Spine **C_Spine01:_02_Out** sur le **C_Spine01Rib02:_Bot_Pos** du Rib02, nommée "**C_Spine01Rib02_BotPos_Poc**".
* Une contrainte Orient **multiple** de **C_Spine01:_02_Out** et **C_Spine01:_01_Out** sur **C_Spine01Rib02:_Bot_Pos**, nommée "**C_Spine01Rib02_BotPos_Orc**"

* Pour finir on fait une Contraine Scale (sans maintain offset) du premier joint de la Spine **C_Spine01:_01_Out** sur le Grp **C_Spine01Rib01:_Input_Grp** du Rib01 et une autre Contrainte Scale (sans maintain offset) du deuxième joint de la Spine **C_Spine01:_02_Out** sur le Grp **C_Spine01Rib02:_Input_Grp** du Rib02.
![](https://i.imgur.com/5nF790h.png)

* Sur la Contrainte Orient du C_Spine01Rib02:_Bot_Pos  du Rib02 on vient passer l'InterType en Shortest.
![](https://i.imgur.com/3Ex8SS2.png)

* On vient ranger les Grp des modules. Pour ça on peut faire des groupes **nulls** (**Input_Grp**, **RigSystem_Grp**, **Ctrls_Grp**, **Output_Grp** et **Trash_Grp**) dans lesquels on vient ranger chaque Grp des modules correspondant, puis on range aux endroits dédiés dans le **RigHierarchy**.

*Exemple pour les groupes **Input** et **Output***
![](https://i.imgur.com/chT9J3o.png)



### **CONTRÔLEUR DE VISIBILITE**
:::info
On va maintenant connecter l'attribut de visiblité des contrôleurs des Ribbons à un module prévu à cet effet, il nous servira aussi pour la visibilité des contrôleurs de Rig Addtionnels.
:::
* Dans le Loader on vient chercher RIGVisibility01_Classic qu'on importe dans la scène mais pas en REF.
![](https://i.imgur.com/hJLBdfB.png)

* On supprime son NameSpace et on le range dans le **Ctrls_Grp** du **Top** Node de RIG.
![](https://i.imgur.com/OY2NEkI.png)

* On Renomme le Groupe **U_Vis01_Ctrls_Grp** et le Ctrl **U_Vis01_01_Ctrl**.
![](https://i.imgur.com/NaPYFrB.png)

* On le place et on va ensuite le contraindre au contrôleur Traj Anim.
* On vient donc chercher le **Ctrl Anim Traj** puis le groupe **U_Vis01_Ctrls_Grp** et on fait une connexion `World Matrix -> offset Parent Matrix`.
![](https://i.imgur.com/KAPD7Zt.png)

* Pour connecter la visibilité des contrôleurs on prend le **Ctrl Visibility** dans le node editor puis on vient chercher: 
* Les groupes **_Rib_Grp** du Rib01 et Rib02 sur lesquels on connecte la visibilité de l'attribut Rib Vis.
![](https://i.imgur.com/I1SpRiq.png)

* Il reste ensuite à connecter la visibilité de l'attribut **Bezier Handle Vis** et **Bezier Master Vis**. Pour ça, on va chercher les Shapes des contrôleurs **A_Ctrl** et **B_Ctrl** des Rib01 et Rib02 pour la visibilité des **Bezier Master**. Et les Shapes des Ctrl **A_Hndle_Ctrl** et **B_Hndle_Ctrl** pour la visibilité des **Bezier Handle**. Et enfin on connecte dans le node editor.
![](https://i.imgur.com/sgYtkt4.png)

:::info
Ce contrôleur de visibilité nous resservira plus tard pour connecter la visibilité des Ctrl d'extra Rig, des jambes, des bras etc.
:::

### **LES JAMBES**
* Dans le Loader on prend le module **RIGLeg01_Classic** et on renomme son Namespace **L_Leg01**.
* On place le module à l'aide des locators Leg_Pos (Hanche, Genou, Cheville, Pied et Orteils) et ensuite on vient placer les points Pivots avec les locators pour le Heel, les Toes et les Bank.
![](https://i.imgur.com/GF9wA63.png)
![](https://i.imgur.com/QcjDMHk.png)

* On peut replacer le contrôleur IK/FK avec le locator UI_Pos.
* On vient importer les Ribbons 01 et 02. C'est le même fonctionnement que pour la Spine expliqué plus haut, le Ribbon02 va être placé sur la partie haute de la jambe, le **Bot_Pos** au niveau de la hanche et le **Top_Pos** au niveau du genou, dessus on va accrocher le Ribbon01, le **Bot_Pos** au niveau du genou et le **Top_Pos** au niveau de la cheville.
* On gère la taille des contrôleurs avec les **TrashGrp** ou avec les points des Ctrl.

:::info
Pour faire la jambe droite, sur le module de Jambe, il y'a un attribut "**Flip**" sur l'**Input** qui permet de faire un miroir, puis il suffit de reporter les valeurs des **Pos** sur la droite.
*TIP : en sélectionnant d'abord les locators de droite, puis ceux de gauche, et en faisant "TAB" sur les attributs de la channelBox, on récupère les transfoms.*
On fait ça aussi sur les **Pos** des Ribbons. Pour les Ribbons on fait un Scale -1 sur le groupe **Input** pour flipper. On a plus ensuite, qu'à connecter les modules.
:::
**ATTENTION: quand on place les jambes, des valeurs se mettent sur les ctrl FK, il faut bien penser à les transferer dans les joints orient et les remettre à 0!!!**
![](https://i.imgur.com/bmd49ek.png)

* On vient donc faire les mêmes contraintes que pour la Spine sur chaque jambe. Donc les deux Ribbons entre eux, puis les joints de la Leg sur les Grp de **Pos** et enfin les **Scales**. Ne pas oublier de renommer les contraintes.
* On pense à mettre l'attribut **Bezier Handle** des Ctrl Bezier Master du haut et du bas des jambes à **0**. et la contrainte Orient en **shortest**.
![](https://i.imgur.com/LDtLSMU.png)


* On connecte ensuite la visibilité des contrôleurs des Ribbons de la même manière que pour la Spine.
* Comme pour la Spine, on vient ranger les Grp des modules. Pour ça, on peut faire des groupes nulls (**Input_Grp**, **RigSystem_Grp**, **Ctrls_Grp**, **Output_Grp** et **Trash_Grp**) dans lesquels on vient ranger chaque Grp des modules correspondant. Puis on range aux endroits dédiés dans le RigHierarchy.

### **LES BRAS**
* Dans le Loader on prend le module **RIGIkFkChain01_Classic** et on renomme son Namespace **L_Arm01**.
* On place le module à l'aide des **_Pos** dans le Grp **Input** (épaule, coude et poignet).
* On peut replacer le contrôleur IK/FK avec le locator **Ui_Pos**.
* *Afin d'éviter les décalages de rotations lors du passage de l'Ik à FK, il faut reporter les valeurs de rotations du premier joint de la chaîne sur le groupe parent du ctrl Ik ("LArm01:IkCtrlGrp"). Pour cela, il faut unlock ce groupe.*
* On vient importer les Ribbons 01 et 02. C'est le meme fonctionnement que pour la Spine expliqué plus haut, le Ribbon02 va être placé sur la partie gauche du bras, le **Bot_Pos** au niveau de l'épaule et le **Top_Pos** au niveau du coude. Dessus on va accrocher le Ribbon01, le **Bot_Pos** au niveau du coude et le **Top_Pos** au niveau du poignet.
* On gère la taille des contrôleurs avec les **TrashGrp** ou avec les points des Ctrl.

:::info
Pour faire le bras droit, sur le module IkFk il y'a un attribut "**Flip**" sur l'**Input** qui permet de faire un mirroir Puis il suffit de reporter les valeurs des **Pos** sur la droite.
*TIP : en sélectionnant d'abord les locators de droite, puis ceux de gauche, et en faisant "TAB" sur les attributs de la channelBox, on récupère les transfoms.*
On fait ça aussi sur les **Pos** des Ribbons. Pour les Ribbons on fait un Scale -1 sur le groupe **Input** pour flipper. On a ensuite plus qu'à connecter les modules.
:::

**ATTENTION: quand on place les bras, des valeurs se mettent sur les ctrl FK, il faut bien penser à les transferer dans les joints orient et les remettre à 0 (comme pour les jambes)!!!**


* On vient faire les mêmes contraintes que pour la Spine sur chaque bras. Donc les deux Ribbons entre eux puis les joints du **Arm_01** sur les Grp de **Pos** et enfin les **Scales**. Ne pas oublier de renommer les contraintes.
* Mettre l'attribut **Bezier Handle** des Ctrl Bezier Master des épaules et des poignet à **0** et la contrainte Orient en **Shortest**.
* On connecte ensuite la visibilité des Contrôleurs des Ribbons de la même manière que pour la Spine et les Jambes.
* Comme pour la Spine et les jambes, on vient ranger les Grp des modules. Pour ça, on peut faire des groupes **nulls** (**Input_Grp**, **RigSystem_Grp**, **Ctrls_Grp**, **Output_Grp** et **Trash_Grp**) dans lesquels on vient ranger chaque Grp des modules correspondant. Puis on range aux endroits dédiés dans le RigHierarchy.

### **LES MAINS**
* Dans le Loader on prend le module **RIGHand01_Classic** avec le nombre de doigts et de joints qui nous intéresse. On renomme son Namespace **L_Hand01**.
* On place le module à l'aide des Grp **Pos** dans le Grp **Input**, on snap le wrist de la main à celui du bras.
![](https://i.imgur.com/bLTWu8F.png)

* On place les contrôleurs au dessus des doigts en sélectionnant les points. On peut les grossir dans le **TrashGrp**.
![](https://i.imgur.com/ecOWhaj.png)

* On va relier la main en IO au dernier joint du module IK/FK du bras, on ne va donc pas avoir besoin du ctrl Wrist, car c'est le controlleur du bras qui va etre utilisé, on vient donc cacher la shape du Ctrl Wrist du poignet.
![](https://i.imgur.com/ZX2cndZ.png)


:::info
Pour faire la main droite, il suffit de reporter les valeurs des **Pos** de la gauche sur la droite.
*TIP : en faisant "TAB" sur les attributs de la ChannelBox.*
Puis on vient faire un Scale -1 sur le Groupe **Input** de la main droite.
:::

* Comme pour les précédents modules, on vient ranger les Grp des modules de mains aux endroits dédiés dans le RigHierarchy.

### **LE COU**
* Dans le Loader on prend un module **RIGBasichChain** avec le nombre de joints qui nous intéresse, et on renomme son Namespace **C_Neck01**.
* On place la module toujours avec les Grp **Pos** dans **Input**.
* On gère la taille des contrôleurs dans le **TrashGrp** ou avec les points des Ctrl.

### **LA TETE**
* Dans le Loader on prend un module **RIGBasichChain** avec un joint, et on renomme son Namespace **C_Head01**.
* On place le module avec le Grp **Pos** dans **Input**.
* On gère la taille des contrôleurs dans le **TrashGrp** ou avec les points des Ctrl.

### **LE HIP**
* On va venir ajouter un joint pour créer un bassin.
* On load un BasicChain de 1 joint qu'on vient placer au bassin, il va venir se connecter en IO sous le Root, et les Jambes vont se connecter sous le HIP.
![](https://i.imgur.com/c8bBAPH.png)
* Il va maintenant falloir contrainte les pieds au Ctrl Traj pour obtenir le mouvement de bassin souhaité.
* On prend le Ctrl Traj Anim et le groupe au dessus de l'Ik du pied et on fait une contrainte parent avec offset, qu'on renomme conformément à la nomenclature du pipe.
![](https://i.imgur.com/E2gK7Jd.png)


### **CONNEXIONS IO**
:::info
Il va maintenant falloir connecter les modules entre eux, pour ça on passe par des connexion IO qui fonctionnent comme des portails avec une entrée et une sortie. Les Out servent à recevoir des In. Les Out sont créés à partir des joints Output et les In sont créés partir des Groupes Input des modules.
:::
* Exemple : pour la Spine; on veut la relier au Joint de Root; la sortie **IO** du Cog existe déjà; on va donc créer le **In** qui va aller s'y connecter.
* On prend le groupe **Input** de la Spine et on exécute le script **`Create Matrix In`** situé dans la shelf ==MM_Rigging==.
![](https://i.imgur.com/ya6U4cl.png)

* On renomme correctement le groupe qui vient de se créer (on enlève "_Input_Grp").
* On peut maintenant connecter la Spine au Cog juste en glissant le Groupe In_Prx qu'on vient de créer dans **C_Root01_CogOut_Prx** dans le groupe **RigModuleIO_Prx** de la hiérarchie.
![](https://i.imgur.com/elwS97W.png)

* Désormais la Spine est bien entrainée par le Cog.

:::info
On peut faire pareil pour les Legs qui seront aussi entrainées par le Cog. En revanche il arrive qu'on ait besoin de créer un nouveau Grp Out_Prx pour relier un module, nous allons maintenant voir comment faire.
:::

* Pour relier les Bras à la Spine il nous manque un "portail" de sortie, on va donc le créer à partir d'un joint de la Spine.
* On repère le joint Output qui nous intéresse (pour relier les bras ce sera le dernier joint du Ribbon02), on le sélectionne et on exécute le script **`Create Matrix Out`** dans la shelf ==MM_Rigging==.
![](https://i.imgur.com/tRRQZyJ.png)

* On renomme le Groupe qu'on vient de créer en enlevant ": et le _ entre le numero de joint et Out" on a donc ici "C_Spine01Rib02_06Out_Prx".
* On vient le ranger dans le Groupe RigModuleIO_Prx de la hiérarchie.
* On peut maintenant créer les In_Prx des Bras comme on a fait plus haut et les ranger dans le Out_Prx de la Spine qu'on a fait.
![](https://i.imgur.com/nWPP6Xx.png)

:::info
On accroche de cette façon là tous les modules, en réfléchissant bien à quel joint on veut se raccrocher pour bien créer les Out_Prx.
:::
**ATTENTION, pour la connexion IO de la main au bras, on fait le Out_PRX à partir du dernier joint du bras et non pas celui du Ribbon!**

### **LES SPACE SWITCHS**
* On vient ajouter des switchs sur les bras et la tete pour que les animateurs puissent choisir quel controlleur ils vont suivre.
* ewemple avec le switch de la tête:on séléctionne le controlleur de la tête et on lance le script space switch et on fait Driven_ctrls
![](https://i.imgur.com/5yRy8OQ.png)

* On vient ensuite sélectionner tous les controlleurs que la tête pourra suivre (Traj Anim, COG Anim, Spine, Neck) et on fait Driver_Ctrls
![](https://i.imgur.com/WD5Q8T4.png)

* On renomme dans la colonne de droite en fonction du ctrl correspondant:
![](https://i.imgur.com/ga5RIpN.png)

* On "Launch Spaceswitch" avec le node Editor d'ouvert à coté
* On vien tbien renommer les nodes pour que le Sanity Check passe
![](https://i.imgur.com/QALuGEW.png)
* Sur le ctrl de la tete on peut venir activer les attributs qui nosu interesse et switcher entre les différents "drivers"
![](https://i.imgur.com/TWNQxsY.png)
* Dans le NameSpace Editor il faut Delete les NameSpaces du SpaceSwitch
![](https://i.imgur.com/gw3eHGY.png)


ON PEUT FAIRE LA MEME CHOSE SUR LES IK DES BRAS.

### **RIG DES ACCESSOIRES**

:::info
Pour les vêtements et accessoires on a souvent besoin de BasicChain, comme le cou et la tête. On les place avec les Pos dans Input, on peut gérer la taille des contrôleurs dans TrashGrp et on les connecte en IO au joint Out dont on a besoin.
On fait attention à l'orientation des joints.
On peut venir connecter leur visibilité au contrôleur de visibilité et ajouter des attributs s'il le faut.
:::

### **DUPLICATION DES JOINTS DE SKIN**
:::info
Les joints Output ne servent pas à skinner, on va donc devoir les dupliquer pour créer une chaîne de joints de skin.
:::
* Commençons par exemple par la Spine, on vient sélectionner le premier joint de la hiérarchie dans l'Output de Rib01 (Quand il y a des Ribbons on ne duplique que les joints des Ribbons, pas de la Spine, de la Leg ou des Bras).
* On duplique cette chaîne et on la renomme "**nomdumodule**__nomdujoint_**_SkJnt**"
* On la sort de la hiérarchie en la sélectionnant et en tapant `parent -r -w` en MEL, ou `maya.cmds.parent(r=1,w=1)` en Python.
![](https://i.imgur.com/77gthBQ.png)

* Dans le Node Editor, on prend la chaîne de joints Output et la chaîne de joints SkJnt.
* Pour les premiers joints on va mettre une **MultMatrix** et une **DecomposeMatrix** (pas besoin pour les autres joints de la chaîne).
* Dans le **MultMatrix** on connecte la `World Matrix` du joint **Output01** et la `Parent Inverse Matrix` du joint **SkJnt01** en `Matrix In[0]` et `Matrix In[1]`.
* Dans le **DecomposeMatrix**, on connecte dans `Input Matrix` la sortie `Matrix Sum` du **MultMatrix** et on relie les sorties (outputTranslate/outputRotate/outputScale) du **decomposeMatrix** aux transforms correspondants du joint **SkJnt 01**.
* On renomme MultMatrix et DecomposeMatrix (nom du joint SkJnt avec **Out** devant **SkJnt**. Ne pas mettre d'underscore ( _ ) entre le num du joint **Out** et **SkJnt** et **_Mxm** ou **_Dcm**)
![](https://i.imgur.com/3xhh6IR.png)

* Pour tous les autres joints de la chaîne on fait des connexions `Matrix` Local du joint **Output** vers le joint **SkJnt**, en passant par un **DecomposeMatrix**, qu'on renommera également.
![](https://i.imgur.com/ICfJOC6.png)

* On sélectionne ensuite la chaîne de Joints **SkJnt**, puis dans SkinJoints de la RigHierarchy on prend le joint auquel on veut que le module soit raccroché (Cf les connexions IO) et on fait `parent -r` en MEL, ou `maya.cmds.parent(r=1)` en Python, pour parenter.
![](https://i.imgur.com/591C71L.png)


:::info
On fait ça pour tous les modules, afin d'obtenir le squelette entier en **SkJnt**.
**Pour les Ribbons où sont attachés les pieds et les mains on supprimera le dernier joint, car sinon il y aura un doublon avec la cheville et le poignet.**
:::

* Quand tout est bien rangé, les joints de skin dupliqués, les IO connectés, on "FileSave", "Validate" pour le Sanity Check et on "Publish". (S'il y a des erreurs dans le sanity Check, on peut cliquer dessus pour voir de quoi il s'agit et les corriger).

:::info
**POUR TOUS LES MODULES: on lock and hide les attributs non animables!**
:::

## **2.** **SKINNING**
* On ouvre la scène de Rigging et on "FileSave" en Skinning.
* On sélectionne les SkinJoints et les meshes et on "Bind Skin".

* Quand le Skin est terminé on "FileSave", "Validate" pour le Sanity Check et on "Publish".
