Éditeur de Graphiques d'Animation

*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.

L'Éditeur de Graphiques d'Animation est un outil visuel basé sur des nœuds qui permet aux artistes techniques et aux animateurs de construire une logique d'animation complexe directement dans Roblox Studio. En fournissant une interface simplifiée pour créer des comportements comme des arbres de mélange, il élimine la dépendance traditionnelle à la scriptation manuelle pour le mouvement des personnages.

Ce système fonctionne en tandem avec votre flux de travail d'animation existant :

  • Éditeur d'Animation : Continuez à utiliser l'Éditeur d'Animation comme votre outil principal pour créer des clips individuels et peaufiner les images clés et les courbes.
  • Éditeur de Graphiques d'Animation : Utilisez cet outil pour prendre ces clips et les organiser dans un arbre logique pour piloter un comportement de jeu sophistiqué.

Conçu pour améliorer la collaboration, le graphique visuel permet aux développeurs d'inspecter, de déboguer et de comprendre rapidement la logique créée par les animateurs. Pendant que les artistes se concentrent sur le raffinement du mouvement interactif, les développeurs peuvent toujours accéder aux nœuds du graphique d'animation de manière programmatique pour un contrôle direct sur les animations et états mélangés.

Construire un graphique

Pour commencer à construire la logique pour un personnage animable, accédez à l'éditeur de graphiques d'animation via l'onglet Avatar dans le ruban Studio. Les étapes suivantes montrent comment initialiser un rig et construire un réseau de nœuds de base en utilisant les animations de marche et de salutation par défaut.

Pour une plongée plus profonde dans les applications pratiques, vous pouvez explorer le Fichier de Référence de Graphiques d'Animation, qui contient à la fois des exemples d'implémentation fondamentaux et complexes.

Pour créer votre propre graphique d'animation, similaire à l'exemple de base fourni dans la référence, utilisez les étapes suivantes :

  1. Dans Studio, ajoutez un rig animable en naviguant vers l'onglet Avatar et en sélectionnant Personnage ⟩ Mon Avatar.

    Bouton Personnage mis en surbrillance dans la barre d'outils de Studio.
  2. Ouvrez l'Éditeur de Graphiques d'Animation en naviguant vers Éditeur de Graphiques dans l'onglet Avatar.

    Éditeur de Graphiques d'Animation indiqué dans la barre d'outils de Studio.
  3. Sélectionnez le rig animable dans la vue 3D. Dans la vue de l'éditeur de graphiques, sélectionnez Graphique dans le coin supérieur gauche et sélectionnez Nouveau pour créer un nouveau graphique.

  4. Dans l'Éditeur de Graphiques, faites un clic droit et sélectionnez Insérer Nœud ⟩ Clip.

    Liste des nœuds dans un menu contextuel
  5. Dans le nouveau nœud Clip, définissez l'ID d'Animation.

    1. Sélectionnez le menu déroulant ID d'Animation.

    2. Pour soumettre un ID d'actif d'animation spécifique, cliquez sur Importer.

      Indiqué un champ sur le module d'importation d'animation pour ajouter l'ID d'Animation
    3. Dans le champ ID d'Animation, ajoutez l'animation de marche par défaut : 507777826.

    4. Sélectionnez Importer.

  6. Ajoutez un autre nœud clip en répétant les étapes 4-5 en utilisant l'animation de salutation par défaut : 507770239.

    Deux nœuds clip avec un ID d'Animation peuplé
  7. Dans l'Éditeur de Graphiques, faites un clic droit et sélectionnez Ajouter.

    Ajouter un nœud
  8. Connectez les nœuds Clip au nœud Ajouter en faisant glisser le connecteur de sortie en haut à droite vers le port approprié :

    1. Connectez le nœud Clip avec l'animation de marche au port Base.
    2. Connectez le nœud Clip avec l'animation de salutation au port Additif.
    Les deux nœuds clip attachés au nœud ajouter
  9. Depuis le nœud Ajouter, connectez le connecteur de sortie en haut à droite au port de sortie du Graphique Pose.

    Tous les nœuds connectés à un nœud de sortie final
  10. OPTIONNEL
    Assignez un paramètre à votre variable Vitesse.

    1. Cliquez et faites glisser le port de Vitesse vert vers une zone vide. Un nouveau nœud de paramètre s'affiche.

      Cliquer et faire glisser le connecteur depuis le port de Vitesse du nœud Clip.
    2. Dans le coin supérieur gauche de l'éditeur de graphiques, utilisez le panneau de paramètres pour modifier rapidement les paramètres dans vos nœuds. Vous pouvez également y accéder de manière programmatique.

      Panneau de paramètres, nœud de paramètre et nœud clip montrant des valeurs partagées.
  11. Testez l'animation en appuyant sur le bouton de lecture.

    Icône du bouton de lecture pour prévisualiser les animations
  12. Essayez de tester divers poids, vitesses, modes de lecture et autres animations. Pour plus d'informations sur les nœuds individuels, consultez la référence des nœuds.

Intégration API

Créer et déployer un Graphique d'Animation suit le pipeline d'animation standard de Roblox. Après avoir sélectionné un rig dans l'Éditeur de Graphiques d'Animation, un nouvel actif AnimationGraphDefinition est créé. Cet actif sert de conteneur pour vos nœuds, connexions et paramètres. Une fois votre logique finalisée, vous publiez le graphique pour recevoir un ID d'Actif standard.

Dans vos scripts, vous interagissez avec ces graphiques en les chargeant sur un Animator comme vous le feriez avec une animation traditionnelle. Pour piloter la logique interne du graphique, utilisez AnimationTrack:SetParameter() pour passer des valeurs en temps réel—comme la vitesse de mouvement ou des booléens d'état—directement dans les variables du graphique.

local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://123456789" -- Votre ID de Graphique Publié
local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()
-- Mises à jour dynamiques des paramètres via RunService
game:GetService("RunService").Stepped:Connect(function(_, dt)
local currentSpeed = humanoidRootPart.AssemblyLinearVelocity.Magnitude
animationTrack:SetParameter("humanoidSpeed", currentSpeed)
end)

Référence des nœuds

Règles d'événements globaux

Pour tous les nœuds et transitions, les règles suivantes s'appliquent par défaut :

  • Les événements se propagent vers le haut depuis leur nœud source à travers le graphique. Chaque événement porte un poids représentant l'influence de sa source dans le mélange final. Si le poids atteint zéro à un moment donné, l'événement est silencieux.
  • Les nœuds sans logique d'événements personnalisée transmettent tous les événements sans changement ; les nœuds qui mélangent ou sélectionnent entre les entrées peuvent échelonner le poids ou bloquer les événements des entrées non primaires (voir la section Événement par nœud).
  • Les événements de marqueur qui atteignent le sommet du graphique peuvent être observés via AnimationTrack:GetMarkerReachedSignal().

Transitions

Plusieurs nœuds dans le Graphique d'Animation (comme Sélectionner, Sélection Prioritaire, Séquence, et Séquence Aléatoire) gèrent comment les animations se mélangent lors du passage entre les entrées actives. Pour éviter la redondance dans la référence des nœuds, ces comportements sont définis par des groupes de propriétés de transition standardisées.

Transition par défaut

Transition par défaut

Le comportement de mélange de base appliqué au nœud chaque fois qu'il passe à une nouvelle entrée active.

Surcharge de transition

Surcharge de transition

Propriétés de lien spécifiques à l'entrée qui supplantent la transition par défaut. Les durées et courbes de surcharge s'appliquent lorsque le nœud passe à cette entrée, sauf pour les transitions Avant Fini, qui utilisent les surcharges de l'entrée sortante.

Timing de transition

Pour les types de nœuds de séquence, les paramètres suivants contrôlent quand la séquence passe à l'entrée suivante :

  • WaitFor (Enum.AnimationNodeWaitFor) : Définit la condition pour avancer. Utilisez Enum.AnimationNodeWaitFor|Finished (par défaut) pour attendre que l'entrée actuelle se termine ou complète une boucle, ou Enum.AnimationNodeWaitFor|Trigger pour avancer lorsque WaitForTrigger est true. Définissez le défaut au niveau du nœud avec DefaultWaitFor, ou remplacez-le pour une entrée avec TransitionOverrideWaitFor.
    • Quand (Enum.AnimationNodeTransitionWhen) : S'applique lorsque Wait For est Enum.AnimationNodeWaitFor|Finished. Définissez le défaut au niveau du nœud avec DefaultTransitionWhen, ou remplacez-le pour l'entrée sortante avec TransitionOverrideWhen.
      • Enum.AnimationNodeTransitionWhen|Finished (par défaut) : Commence à se mélanger après que l'entrée actuelle se termine.
      • Enum.AnimationNodeTransitionWhen|BeforeFinished : Commence à se mélanger une durée de transition avant que l'entrée actuelle se termine, de sorte que le mélange chevauche la fin de son animation. Par exemple, une transition de 0,2 seconde commence pendant les 0,2 secondes finales de l'animation.

RandomSequenceNode prend également en charge DefaultTransitionWhen et TransitionOverrideWhen pour contrôler quand le mélange commence.

Pour les transitions de machine d'état, voir Propriétés de transition.

Réplication

Les paramètres du graphique d'animation et l'état interne des nœuds se répliquent automatiquement. Le mode de réplication est déterminé par Workspace.AuthorityMode au moment où le script Animate est créé :

Exemples de Scripts Animate

Pour générer des scripts d'exemple pour piloter un graphique d'animation pour un rig, utilisez Graphique -> Créer un script Animate dans l'Éditeur de Graphiques d'Animation. Cela produit une hiérarchie de script placée sous StarterCharacterScripts (pour les personnages joueurs) ou directement sur le rig (pour les PNJ) :

Animate (ModuleScript)
├── RunClient (LocalScript)
└── RunServer (Script, RunContext = Legacy)

Le script Animate ModuleScript contient la logique de chargement du graphique. Les scripts RunClient et RunServer l'invoquent dans le contexte approprié. Les scripts inclus dépendent du cas d'utilisation :

Cas d'utilisationScripts InclusComportement
PNJ (tous modes)RunServerLe serveur charge et joue le graphique. L'état se réplique automatiquement à tous les clients.
Joueur + Enum.AuthorityMode.ServerRunServer + RunClientLe serveur pilote le graphique de manière autoritaire. Le client propriétaire active Enum.PredictionMode pour la prédiction locale basée sur le rollback.
Joueur + Enum.AuthorityMode.AutomaticRunClientLe client propriétaire charge et joue le graphique. Les paramètres se répliquent automatiquement vers le serveur et d'autres clients.

Les attributs suivants sont stockés sur le script Animate et configurent son comportement :

AttributTypeDescription
GraphNameStringNom de l'actif de graphique d'animation.
CharacterNameStringNom du rig que le graphique cible.
SourceAssetIdStringL'ID d'Actif publié du graphique. Utilisé à l'exécution dans les jeux publiés.
IsServerAuthorityBooleanIndique si le script a été créé avec Workspace.AuthorityMode défini sur Server. Détermine la stratégie de réplication.
PreviewInStudioBooleanLorsque vrai (par défaut), le test de jeu dans Studio charge le graphique non publié localement afin que vous puissiez itérer sans publier. Définissez sur faux pour tester l'actif publié dans Studio. Notez que cela n'est actuellement pas pris en charge dans Enum.AuthorityMode.Server.

Réplication des paramètres en mode Automatique

Lorsque Workspace.AuthorityMode est Automatique :

  • Le client propriétaire pilote les graphiques des personnages joueurs ; le serveur pilote les graphiques des PNJ.
  • Les paramètres définis via AnimationTrack:SetParameter() se répliquent automatiquement vers d'autres pairs. Plusieurs appels SetParameter dans une seule image sont coalisés (dernier écrivain gagne).
  • Aucun script supplémentaire n'est nécessaire pour le transport des paramètres — le moteur gère la réplication en interne.
  • D'autres clients voient les mises à jour des paramètres avec un léger retard (un intervalle d'envoi plus la latence réseau).

Autorité du serveur

Lorsque Workspace.AuthorityMode est Serveur :

  • Le serveur est autoritaire pour tous les graphiques — il exécute la simulation et réplique l'état complet du graphique.
  • Ce qui est répliqué : À la fois les paramètres et l'état interne des nœuds, y compris le temps écoulé, les sélections actuelles, la progression des transitions, les comptes de boucle et les graines RNG. Cela garantit que tous les clients voient un comportement d'animation identique.
  • Personnages joueurs : Le serveur pilote le graphique. Le script RunClient du client propriétaire active automatiquement Enum.PredictionMode sur le Animator, de sorte que le joueur local voit une animation fluide et prédite qui se réconcilie avec le serveur en cas de désaccord.
  • PNJ : Le serveur pilote exclusivement le graphique ; les clients observent l'état répliqué sans simulation locale.

Pilotage des paramètres

Utilisez AnimationTrack:SetParameter() depuis chaque script qui exécute le graphique :

  • PNJ (tous modes) : Appelez SetParameter depuis RunServer (ou tout Script serveur ayant accès au AnimationTrack).
  • Personnage joueur en Enum.AuthorityMode.Server : Appelez SetParameter depuis RunServer et RunClient. Le serveur a besoin des paramètres pour piloter la simulation autoritaire, et le client propriétaire a besoin des mêmes paramètres pour piloter sa prédiction locale.
  • Personnage joueur en Enum.AuthorityMode.Automatic : Appelez SetParameter depuis RunClient (ou tout LocalScript client ayant accès au AnimationTrack).

Le script Animate généré inclut un bloc SetParameter commenté comme point de départ. Décommentez et modifiez-le pour piloter les paramètres à partir de l'état de jeu (vitesse de mouvement, état humanoïde, direction d'entrée, etc.).

©2026 Société Roblox. Roblox, le logo Roblox et Powering Imagination font partie de nos marques déposées aux États-Unis et dans d'autres pays.