Communitygithub.com

Système d'Animation UE

Expert dans le système d'animation d'Unreal Engine, couvrant AnimInstance, montages, blend spaces, IK, et graphes d'animation liés.

Qu'est-ce que Système d'Animation UE ?

Ce skill fournit une expertise complète sur le système d'animation d'Unreal Engine, destinée aux développeurs utilisant des outils comme Claude Code, Cursor ou Codex. Il couvre l'architecture des AnimInstances avec leurs phases de mise à jour thread-safe (NativeUpdateAnimation et NativeThreadSafeUpdateAnimation), la gestion des montages avec leurs délégués et la réplication multijoueur, les blend spaces 1D/2D et aim offsets, les machines d'état avec transitions et conduits en C++ natif, les anim notifies point-in-time et duration, l'IK procédural avec foot IK et contrôleurs squelettiques, ainsi que les graphes d'animation liés par interface ou par tag. Il est utile pour tout projet Unreal Engine nécessitant une animation performante, modulaire et adaptée au multijoueur ou à GAS.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/quodsoler/unreal-engine-skills/ue-animation-system

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Système d'Animation UE ?

Vous êtes un expert du système d'animation d'Unreal Engine.

Vérification du Contexte

Lisez d'abord .agents/ue-project-context.md. Notez quels plugins sont activés (Control Rig, Motion Matching, Full Body IK), si GAS est utilisé, et la hiérarchie du squelette/du personnage.

Informations à Recueillir

  1. Quel besoin d'animation ? (locomotion, ability, cinématique, IK, procédural)
  2. C++ uniquement, Blueprint uniquement, ou mixte ?
  3. Le personnage utilise-t-il ACharacter avec un USkeletalMeshComponent existant ?
  4. GAS est-il actif ? (affecte la réplication des montages)
  5. Multijoueur ? (détermine la stratégie de réplication)
  6. Le projet utilise-t-il des couches d'animation liées modulaires ?

Architecture

ACharacter / AActor
  └── USkeletalMeshComponent
        └── sous-classe UAnimInstance
              ├── NativeInitializeAnimation()           [initialisation, thread de jeu]
              ├── NativeUpdateAnimation(float dt)       [thread de jeu]
              ├── NativeThreadSafeUpdateAnimation(dt)   [thread de travail]
              ├── FAnimInstanceProxy                    [évaluation thread de travail]
              └── API Montage / Couches Liées

Les mises à jour d'animation s'exécutent en deux phases. Thread de jeu : NativeUpdateAnimation — sûr pour lire l'état du gameplay. Thread de travail : évaluation de l'arbre de blend. Écrivez tout état partagé comme membres UPROPERTY() Transient dans NativeUpdateAnimation ; lisez ces valeurs mises en cache dans NativeThreadSafeUpdateAnimation.


AnimInstance

Motif de Sous-classe

// MyAnimInstance.h
UCLASS()
class MYGAME_API UMyAnimInstance : public UAnimInstance
{
    GENERATED_BODY()

    virtual void NativeInitializeAnimation() override;
    virtual void NativeUpdateAnimation(float DeltaSeconds) override;
    virtual void NativeThreadSafeUpdateAnimation(float DeltaSeconds) override;

protected:
    UPROPERTY(Transient) TObjectPtr<ACharacter> OwningCharacter;
    UPROPERTY(Transient) TObjectPtr<UCharacterMovementComponent> MovementComp;

    UPROPERTY(Transient, BlueprintReadOnly, Category="Locomotion")
    float Speed = 0.f;

    UPROPERTY(Transient, BlueprintReadOnly, Category="Locomotion")
    float Direction = 0.f;

    UPROPERTY(Transient, BlueprintReadOnly, Category="Locomotion")
    bool bIsInAir = false;
};
// MyAnimInstance.cpp
void UMyAnimInstance::NativeInitializeAnimation()
{
    Super::NativeInitializeAnimation(); // Appelez TOUJOURS super
    OwningCharacter = Cast<ACharacter>(TryGetPawnOwner());
    if (OwningCharacter)
        MovementComp = OwningCharacter->GetCharacterMovement();
}

void UMyAnimInstance::NativeUpdateAnimation(float DeltaSeconds)
{
    Super::NativeUpdateAnimation(DeltaSeconds);
    if (!OwningCharacter || !MovementComp) return;

    const FVector Velocity = MovementComp->Velocity;
    Speed    = Velocity.Size2D();
    bIsInAir = MovementComp->IsFalling();

    if (Speed > 3.f)
    {
        const FRotator ActorRot    = OwningCharacter->GetActorRotation();
        const FRotator VelocityRot = Velocity.ToOrientationRotator();
        Direction = UKismetMathLibrary::NormalizedDeltaRotator(
            VelocityRot, ActorRot).Yaw;
    }
}

void UMyAnimInstance::NativeThreadSafeUpdateAnimation(float DeltaSeconds)
{
    Super::NativeThreadSafeUpdateAnimation(DeltaSeconds);
    // Lisez uniquement les membres UPROPERTY écrits dans NativeUpdateAnimation ci-dessus.
    // N'appelez AUCUNE fonction UObject non marquée BlueprintThreadSafe.
}

FAnimInstanceProxy — Accès Thread-Safe

Une logique d'animation lourde peut s'exécuter sur des threads de travail via NativeThreadSafeUpdateAnimation. Accédez aux données partagées via le proxy :

void UMyAnimInstance::NativeThreadSafeUpdateAnimation(float DeltaSeconds)
{
    FMyAnimInstanceProxy& Proxy = GetProxyOnAnyThread<FMyAnimInstanceProxy>();
    Proxy.Speed = Proxy.Velocity.Size();
    Proxy.bIsFalling = Proxy.MovementMode == EMovementMode::MOVE_Falling;
}
// Déclaration FAnimInstanceProxy — conteneur de données du thread de travail
USTRUCT()
struct FMyAnimInstanceProxy : public FAnimInstanceProxy
{
    GENERATED_BODY()
    FMyAnimInstanceProxy() = default;
    explicit FMyAnimInstanceProxy(UAnimInstance* Instance) : FAnimInstanceProxy(Instance) {}

    float Speed = 0.f;
    FVector Velocity = FVector::ZeroVector;
    TEnumAsByte<EMovementMode> MovementMode = MOVE_None;

    virtual void PreUpdate(UAnimInstance* AnimInstance, float DeltaSeconds) override;
    virtual void Update(float DeltaSeconds) override;
};

// Dans UMyAnimInstance : surchargez CreateAnimInstanceProxy pour retourner votre proxy
virtual FAnimInstanceProxy* CreateAnimInstanceProxy() override
{ return new FMyAnimInstanceProxy(this); }

Le moteur copie les données entre le thread de jeu et le thread de travail à des points de synchronisation sûrs.


Montages

Source : AnimMontage.h, AnimInstance.h

API clé (UAnimInstance) :

float Montage_Play(UAnimMontage*, float PlayRate=1.f,
    EMontagePlayReturnType=MontageLength, float StartAt=0.f, bool bStopAll=true);
void  Montage_Stop(float BlendOut, const UAnimMontage* Montage=nullptr);
void  Montage_Pause(const UAnimMontage* Montage=nullptr);
void  Montage_Resume(const UAnimMontage* Montage);
void  Montage_JumpToSection(FName Section, const UAnimMontage* Montage=nullptr);
void  Montage_SetNextSection(FName From, FName To, const UAnimMontage* Montage=nullptr);
bool  Montage_IsActive(const UAnimMontage*) const;
bool  Montage_IsPlaying(const UAnimMontage*) const;
FName Montage_GetCurrentSection(const UAnimMontage* Montage=nullptr) const;
float Montage_GetPosition(const UAnimMontage*) const;

Motif de Lecture + Délégué

void UMyComponent::PlayAttackMontage(UAnimMontage* Montage)
{
    UAnimInstance* AnimInst = GetMesh()->GetAnimInstance();
    if (!AnimInst || !Montage) return;

    // Lisez d'ABORD — Montage_SetEndDelegate appelle GetActiveInstanceForMontage()
    // en interne, qui retourne nullptr jusqu'à ce que Montage_Play crée l'instance.
    if (AnimInst->Montage_Play(Montage) <= 0.f) return;

    FOnMontageEnded EndDelegate;
    EndDelegate.BindUObject(this, &UMyComponent::OnAttackEnded);
    AnimInst->Montage_SetEndDelegate(EndDelegate, Montage);

    FOnMontageBlendingOutStarted BlendOutDelegate;
    BlendOutDelegate.BindUObject(this, &UMyComponent::OnAttackBlendingOut);
    AnimInst->Montage_SetBlendingOutDelegate(BlendOutDelegate, Montage);
}

void UMyComponent::OnAttackEnded(UAnimMontage* Montage, bool bInterrupted) { }
void UMyComponent::OnAttackBlendingOut(UAnimMontage* Montage, bool bInterrupted) { }

Montage de Slot Dynamique

UAnimMontage* DynMontage = AnimInst->PlaySlotAnimationAsDynamicMontage(
    SomeSequence, FName("UpperBody"), 0.25f, 0.25f, 1.f, 1);

Réplication Multijoueur

  • Avec GAS : utilisez UAbilitySystemComponent::PlayMontage() — GAS gère la réplication via FGameplayAbilityRepAnimMontage.
  • Sans GAS : répliquez un pointeur de montage ou une structure rep personnalisée ; le serveur appelle Montage_Play, les clients jouent sur OnRep_.
  • N'appelez jamais Montage_Play indépendamment sur tous les rôles réseau sans synchronisation.

Intégration GAS — PlayMontageAndWait

// Tâche GAS ability — PlayMontageAndWait (nécessite le module GameplayAbilities)
UAbilityTask_PlayMontageAndWait* Task =
    UAbilityTask_PlayMontageAndWait::CreatePlayMontageAndWaitProxy(
        this, NAME_None, AttackMontage, 1.f);
Task->OnCompleted.AddDynamic(this, &UMyAbility::OnMontageCompleted);
Task->OnInterrupted.AddDynamic(this, &UMyAbility::OnMontageInterrupted);
Task->ReadyForActivation();  // doit être appelé pour démarrer la tâche

Blend Spaces

Les blend spaces sont des assets de données échantillonnés dans l'AnimGraph. Pilotez-les en définissant des membres UPROPERTY sur l'AnimInstance que l'AnimGraph lit.

  • 1D (UBlendSpace1D) : axe unique, typiquement Speed (0–600). Utilisez FInterpolationParameter avec InterpolationType=SpringDamper, InterpolationTime=0.15, DampingRatio=1.0.
  • 2D (UBlendSpace) : deux axes — Direction (-180 à 180) et Speed (0–600). Échantillons de direction cardinale à chaque palier de vitesse.
  • Aim Offset (UAimOffsetBlendSpace) : blend space additif pour le ciblage Yaw/Pitch, placé après la pose de locomotion de base dans l'AnimGraph.

Consultez references/locomotion-setup.md pour la configuration complète des axes et le placement des échantillons.


Machines d'État

Les machines d'État vivent dans l'AnimGraph. Liez la logique C++ native aux règles de transition et à l'entrée/sortie d'état sans Blueprint :

// Dans NativeInitializeAnimation()
AddNativeTransitionBinding(
    FName("LocomotionSM"), FName("Idle"), FName("Walk/Run"),
    FCanTakeTransition::CreateUObject(this, &UMyAnimInstance::CanStartMoving),
    FName("IdleToMoving"));

AddNativeStateEntryBinding(
    FName("LocomotionSM"), FName("Land"),
    FOnGraphStateChanged::CreateUObject(this, &UMyAnimInstance::OnLandEntered));

Interrogez la machine d'état à l'exécution :

const FAnimNode_StateMachine* SM =
    GetStateMachineInstanceFromName(FName("LocomotionSM"));
float RunWeight = GetInstanceStateWeight(
    GetStateMachineIndex(FName("LocomotionSM")), SM->GetCurrentState());

Nœuds Conduit

Les conduits évaluent une seule règle booléenne et bifurquent vers plusieurs états de destination — remplaçant la logique de transition dupliquée. Ajoutez un Conduit dans l'éditeur AnimGraph ; sa CanEnterTransition s'exécute une fois et toutes les transitions sortantes partagent le résultat. Utilisez des conduits lorsque trois états ou plus nécessitent la même condition d'entrée (par exemple, "est au sol ?"). Pour des transitions A→B simples, une règle directe est plus claire.


Anim Notifies

Source : AnimNotify.h, AnimNotifyState.h

UAnimNotify — Ponctuel

UCLASS(meta=(DisplayName="Footstep"))
class MYGAME_API UFootstepNotify : public UAnimNotify
{
    GENERATED_BODY()
public:
    // Surchargez toujours la signature à 3 arguments d'UE5
    virtual void Notify(USkeletalMeshComponent* MeshComp,
        UAnimSequenceBase* Animation,
        const FAnimNotifyEventReference& EventReference) override;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Footstep")
    FName FootSocket = FName("foot_l");
};

UAnimNotifyState — Durée (Début/Tick/Fin)

UCLASS(meta=(DisplayName="Weapon Collision Window"))
class MYGAME_API UWeaponCollisionState : public UAnimNotifyState
{
    GENERATED_BODY()
public:
    virtual void NotifyBegin(USkeletalMeshComponent*, UAnimSequenceBase*,
        float TotalDuration, const FAnimNotifyEventReference&) override;
    virtual void NotifyEnd(USkeletalMeshComponent*, UAnimSequenceBase*,
        const FAnimNotifyEventReference&) override;
};

BranchingPoint (Synchrone)

Définissez bIsNativeBranchingPoint = true dans le constructeur. Surchargez BranchingPointNotify() au lieu de Notify(). Se déclenche de manière synchrone pendant Montage_Advance — utilisez pour les sauts de section et un contrôle précis de la timeline. Tous les autres notifies sont mis en file d'attente (déclenchés après la fin du tick, sûrs pour VFX/SFX).

Délégué de Notify Nommé

AnimInst->OnPlayMontageNotifyBegin.AddDynamic(
    this, &UMyComponent::HandleNotifyBegin);

void UMyComponent::HandleNotifyBegin(FName NotifyName,
    const FBranchingPointNotifyPayload& Payload)
{
    if (NotifyName == FName("EnableHitbox")) ActivateHitDetection();
}

Consultez references/anim-notify-reference.md pour le catalogue de notifies intégrés et plus de motifs personnalisés.


IK et Procédural

Foot IK avec Line Traces (NativeUpdateAnimation — thread de jeu)

FVector UMyAnimInstance::GetFootTarget(FName SocketName) const
{
    const FVector Foot = GetOwningComponent()->GetSocketLocation(SocketName);
    FHitResult Hit;
    FCollisionQueryParams P(SCENE_QUERY_STAT(FootIK), true);
    P.AddIgnoredActor(OwningCharacter);
    if (GetWorld()->LineTraceSingleByChannel(
            Hit, Foot + FVector(0,0,50), Foot - FVector(0,0,75),
            ECC_Visibility, P))
        return Hit.ImpactPoint;
    return Foot;
}

Alimentez les résultats dans un asset Control Rig (recommandé UE5) ou un nœud de contrôle squelettique Two Bone IK dans l'AnimGraph.

Nœuds de contrôle squelettique (AnimGraph) :

NœudObjectif
Two Bone IKIK à deux articulations (bras, jambe) — effecteur + cible d'articulation
FABRIKIK multi-os en chaîne — os de la pointe + effecteur
Look AtOs unique suit un emplacement cible avec limite
Copy BoneCopie les composants de transformation entre les os
Spline IKLes os suivent une courbe spline (colonne vertébrale, queue)

Blend Par Os en Couches (Split Haut/Bas)

Dans l'AnimGraph :

  1. Connectez la sortie de la machine d'état à Base Pose.
  2. Connectez la sortie du slot UpperBody à Blend Poses 0.
  3. Configuration de la couche : Bone=spine_01, Depth=0, MeshPoseBlendFactor=1.0.

Les montages d'attaque utilisent le slot UpperBody ; la locomotion se joue sans interruption en dessous.

Aim Offset

// Dans NativeUpdateAnimation :
const FRotator Delta = UKismetMathLibrary::NormalizedDeltaRotator(
    OwningCharacter->GetBaseAimRotation(),
    OwningCharacter->GetActorRotation());
AimYaw   = FMath::Clamp(Delta.Yaw,   -90.f, 90.f);
AimPitch = FMath::Clamp(Delta.Pitch, -90.f, 90.f);

Placez un nœud Aim Offset après la pose de base dans l'AnimGraph, en alimentant AimYaw et AimPitch.


Graphes d'Animation Liés et Couches

Source : AnimNode_LinkedAnimGraph.h, AnimNode_LinkedAnimLayer.h

Couche d'Animation Liée (Recommandé)

  1. Créez un Blueprint UAnimLayerInterface avec les signatures des fonctions de couche.
  2. L'AnimInstance principale a des nœuds Linked Anim Layer référençant l'interface.
  3. Des sous-classes d'AnimInstance séparées implémentent l'interface par mode.
  4. Échangez à l'exécution :
// Changer l'implémentation de la locomotion
AnimInst->LinkAnimClassLayers(UClimbingLocomotionLayer::StaticClass());
// Réinitialiser toutes les couches aux valeurs par défaut :
AnimInst->LinkAnimClassLayers(nullptr);
// Récupérer une instance liée :
UAnimInstance* Layer =
    AnimInst->GetLinkedAnimLayerInstanceByClass(UClimbingLocomotionLayer::StaticClass());

Graphe d'Animation Lié (par Tag)

AnimInst->LinkAnimGraphByTag(FName("CombatGraph"), UMyCombatAnimInstance::StaticClass());
UAnimInstance* Sub = AnimInst->GetLinkedAnimGraphInstanceByTag(FName("CombatGraph"));

Propagation des Notifies

AnimInst->SetReceiveNotifiesFromLinkedInstances(true);

Références

  • references/ue-animation-system.md — Guide de référence complet
  • references/locomotion-setup.md — Configuration du blend space de locomotion
  • references/anim-notify-reference.md — Catalogue de notifies et modèles

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Skills associés