Communitygithub.com

ue-sequencer-cinematics

Expert dans le Sequencer d'Unreal Engine et les systèmes cinématiques.

Qu'est-ce que ue-sequencer-cinematics ?

Cette compétence fournit une expertise complète pour le Sequencer d'Unreal Engine et les systèmes cinématiques. Elle couvre la lecture de Level Sequences, la gestion des liaisons d'acteurs (Possessables et Spawnables), la configuration de la caméra cinématographique (ACineCameraActor, APlayerCameraManager), et les événements Sequencer (UMovieSceneEvent, ULevelSequenceDirector). Elle offre un guide détaillé pour le code C++, y compris les API dépréciées, les paramètres de lecture, les délégations et les bonnes pratiques. La compétence est utile pour les développeurs créant des cinématiques, des séquences in-game ou des rendus hors ligne, avec des conseils sur le contexte du projet (version UE, multijoueur, modules Build.cs). Elle prend en charge les environnements d'édition et d'exécution, avec des extraits de code prêts à l'emploi et des explications claires. Cette compétence est destinée aux agents IA spécialisés dans le développement de jeux avec Unreal Engine.

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

Demander à votre IA préférée

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

Documentation

Skill : ue-sequencer-cinematics

Vous êtes un expert du Sequencer d'Unreal Engine et des systèmes cinématiques.

Vérification du Contexte

Lisez .agents/ue-project-context.md avant d'écrire du code cinématique pour :

  • La version cible d'UE (la disponibilité des API varie — la propriété SequencePlayer est dépréciée depuis UE 5.4+)
  • Les exigences cinématiques (scènes cinématiques, caméras in-game, rendu hors ligne)
  • Le contexte multijoueur (le comportement de réplication des séquences diffère)
  • Les modules Build.cs déjà déclarés

Collecte d'Informations

Demandez :

  1. Le type de cinématique : scène cinématique plein écran, caméra in-game ou séquence d'ambiance en arrière-plan
  2. Si les acteurs sont liés à l'exécution ou pré-placés dans le niveau
  3. Si le contrôle de la caméra doit revenir au joueur après la lecture
  4. Séquence unique ou en boucle
  5. Gameplay en temps réel ou sortie Movie Render Queue hors ligne

Modules Build.cs

PublicDependencyModuleNames.AddRange(new string[]
{
    "LevelSequence", "MovieScene", "CinematicCamera",
});
// Rendu hors ligne uniquement :
PrivateDependencyModuleNames.Add("MovieRenderPipelineCore");

Lecture des Level Sequences

ALevelSequenceActor — Placé dans le Monde

ALevelSequenceActor possède le lecteur. Utilisez GetSequencePlayer() — la propriété directe SequencePlayer est dépréciée depuis UE 5.4.

// LevelSequenceActor.h : ULevelSequencePlayer* GetSequencePlayer() const;
ULevelSequencePlayer* Player = SeqActor->GetSequencePlayer();
if (Player) { Player->Play(); }

ULevelSequencePlayer::CreateLevelSequencePlayer — Apparition à l'Exécution

// LevelSequencePlayer.h :
// static ULevelSequencePlayer* CreateLevelSequencePlayer(
//     UObject* WorldContextObject, ULevelSequence*, FMovieSceneSequencePlaybackSettings,
//     ALevelSequenceActor*& OutActor);

FMovieSceneSequencePlaybackSettings Settings;
Settings.bAutoPlay              = false;
Settings.PlayRate               = 1.0f;
Settings.LoopCount.Value        = 0;       // 0=une fois, -1=infini
Settings.bDisableMovementInput  = true;
Settings.bDisableLookAtInput    = true;
Settings.bHidePlayer            = false;
Settings.bHideHud               = false;
Settings.bDisableCameraCuts     = false;
Settings.bPauseAtEnd            = false;
Settings.FinishCompletionStateOverride =
    EMovieSceneCompletionModeOverride::ForceRestoreState; // sûr pour les scènes cinématiques interrompables

ALevelSequenceActor* OutActor = nullptr;
ULevelSequencePlayer* Player  = ULevelSequencePlayer::CreateLevelSequencePlayer(
    this, Sequence, Settings, OutActor);

// Stockez OutActor dans une UPROPERTY pour éviter le GC
ActiveSequenceActor = OutActor;

if (Player)
{
    Player->OnFinished.AddDynamic(this, &AMyClass::OnCutsceneFinished);
    Player->Play();
}

Contrôle de Lecture (base UMovieSceneSequencePlayer)

// MovieSceneSequencePlayer.h
Player->Play();
Player->PlayReverse();
Player->PlayLooping(-1);       // -1 = boucles infinies
Player->Pause();
Player->Stop();                // déplace le curseur à la fin, déclenche OnStop
Player->StopAtCurrentTime();
Player->GoToEndAndStop();
Player->SetPlayRate(0.5f);     // négatif = inverse

// Saut à une image (saute les événements entre l'image actuelle et la cible)
// Blueprint expose ceci comme GoToFrame. En C++, utilisez SetPlaybackPosition avec Jump.
Player->SetPlaybackPosition(
    FMovieSceneSequencePlaybackParams(FFrameTime(120), EUpdatePositionMethod::Jump));

// Jouer jusqu'à une image (déclenche tous les événements en cours de route)
Player->PlayTo(
    FMovieSceneSequencePlaybackParams(FFrameTime(240), EUpdatePositionMethod::Play),
    FMovieSceneSequencePlayToParams());

// Restreindre la plage de lecture
Player->SetFrameRange(0, 60);           // images 0–60
Player->SetTimeRange(0.0f, 2.5f);       // secondes

// Interrogation d'état
bool bPlaying = Player->IsPlaying();
FQualifiedFrameTime Now = Player->GetCurrentTime();
FQualifiedFrameTime Dur = Player->GetDuration();

// Délégations (à lier avant Play)
Player->OnFinished.AddDynamic(this, &UMyClass::OnSeqFinished);
Player->OnPlay.AddDynamic(this, &UMyClass::OnSeqPlay);
Player->OnStop.AddDynamic(this, &UMyClass::OnSeqStop);
Player->OnNativeFinished.BindUObject(this, &UMyClass::OnNativeFinished); // non-dynamique

// Événement de coupe caméra (LevelSequencePlayer.h)
// DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnLevelSequencePlayerCameraCutEvent, UCameraComponent*, CameraComponent)
LsPlayer->OnCameraCut.AddDynamic(this, &UMyClass::OnCameraCut);

// Restaurer l'état sur arrêt anticipé (scène cinématique interrompable)
Player->SetCompletionModeOverride(EMovieSceneCompletionModeOverride::ForceRestoreState);
Player->Stop();

// Instantané de sous-séquence
FLevelSequencePlayerSnapshot Snap;
Player->TakeFrameSnapshot(Snap);
// Snap.CurrentShotName, Snap.RootTime, Snap.CameraComponent, Snap.ActiveShot

Liaison d'Acteurs (Actor Binding)

Créez des tags de liaison dans le Sequencer (clic droit sur la liaison d'objet -> Tags...) puis remplacez à l'exécution. Toujours lier avant d'appeler Play().

Spawnables vs Possessables

Possessables se lient à des acteurs mondiaux préexistants (placés dans le niveau ou apparus via le gameplay). Spawnables sont des acteurs que la séquence elle-même crée et détruit.

// Spawnable : la séquence possède le cycle de vie de l'acteur
// Défini dans l'éditeur Sequencer : clic droit sur la piste d'acteur → "Changer en Spawnable"
// À l'exécution, l'acteur apparaît lorsque la séquence atteint sa plage et disparaît lorsqu'il la quitte

// Possessable dynamique : lier un acteur apparu via le gameplay à une piste de séquence
// Créez l'ID de liaison dans l'éditeur, puis remplacez à l'exécution :
FMovieSceneObjectBindingID BindingID = /* depuis l'éditeur de séquence */;
ALevelSequenceActor* SeqActor = /* votre acteur de séquence */;
SeqActor->SetBinding(BindingID, {SpawnedActor});

Pourquoi c'est important : Utilisez les Possessables pour les acteurs mondiaux persistants (portes, ascenseurs) et les Spawnables pour les acteurs transitoires propres aux scènes cinématiques (personnages de cinématique, accessoires). Les Possessables survivent à la fin de la séquence ; les Spawnables sont nettoyés automatiquement.

// LevelSequenceActor.h — toute l'API de liaison se trouve ici

// Remplacer les acteurs liés (préféré : basé sur les tags, résistant aux changements de GUID)
SeqActor->SetBindingByTag(FName("Hero"), TArray<AActor*>{ HeroActor },
    /*bAllowBindingsFromAsset=*/ false);

// Basé sur GUID (exposer FMovieSceneObjectBindingID via UPROPERTY pour l'affectation dans l'éditeur)
// UPROPERTY(EditAnywhere) FMovieSceneObjectBindingID HeroBindingID;
SeqActor->SetBinding(HeroBindingID, TArray<AActor*>{ HeroActor }, false);

// Ajouter sans supprimer les liaisons existantes
SeqActor->AddBindingByTag(FName("NPC"), NpcActor, /*bAllowBindingsFromAsset=*/ true);

// Supprimer / réinitialiser
SeqActor->RemoveBindingByTag(FName("NPC"), NpcActor);
SeqActor->ResetBinding(HeroBindingID);  // revenir à la liaison de l'asset
SeqActor->ResetBindings();              // revenir à toutes les liaisons de l'asset

// Recherche par tag
FMovieSceneObjectBindingID ID = SeqActor->FindNamedBinding(FName("Hero"));
const TArray<FMovieSceneObjectBindingID>& All = SeqActor->FindNamedBindings(FName("NPC"));

// Inspecter ce qui est actuellement lié
TArray<UObject*> Bound = Player->GetBoundObjects(HeroBindingID);

// FMovieSceneObjectBindingID (MovieSceneObjectBindingID.h) :
//   Accès via des accesseurs publics — les champs internes sont privés :
//     GetGuid()              — FGuid identifiant la piste de liaison
//     GetRelativeSequenceID() — quelle sous-séquence le contient (0 = locale)

Système de Caméra

ACineCameraActor / UCineCameraComponent

// CineCameraActor.h : UCineCameraComponent* GetCineCameraComponent() const;
// CineCameraComponent.h / CineCameraSettings.h :
//   FCameraFilmbackSettings Filmback  (SensorWidth, SensorHeight en mm, SensorAspectRatio en lecture seule)
//   FCameraLensSettings LensSettings  (MinFocalLength, MaxFocalLength, MinFStop, MaxFStop en mm)
//   FCameraFocusSettings FocusSettings (FocusMethod, ManualFocusDistance en cm, bSmoothFocusChanges)
//   float CurrentFocalLength  — Interp, animatable dans Sequencer
//   float CurrentAperture     — f-stop, Interp-animatable

ACineCameraActor* Cam = GetWorld()->SpawnActor<ACineCameraActor>(SpawnTransform);
UCineCameraComponent* CC = Cam->GetCineCameraComponent();

FCameraFilmbackSettings FB;
FB.SensorWidth = 36.0f; FB.SensorHeight = 24.0f;  // plein format 35mm
CC->SetFilmback(FB);

CC->SetCurrentFocalLength(50.0f);   // mm
CC->SetCurrentAperture(2.0f);       // f-stop

FCameraFocusSettings FS;
FS.FocusMethod         = ECameraFocusMethod::Manual;  // Manual | Tracking | Disable | DoNotOverride
FS.ManualFocusDistance = 500.0f;    // cm
FS.bSmoothFocusChanges = true;
CC->SetFocusSettings(FS);

// Suivi du regard (CineCameraActor.h : FCameraLookatTrackingSettings LookatTrackingSettings)
Cam->LookatTrackingSettings.bEnableLookAtTracking     = true;
Cam->LookatTrackingSettings.ActorToTrack              = TargetActor;
Cam->LookatTrackingSettings.LookAtTrackingInterpSpeed = 5.0f;
Cam->LookatTrackingSettings.RelativeOffset            = FVector(0, 0, 90.f);

// Empêcher la séquence de remplacer la caméra de gameplay (définir avant Play)
SeqActor->PlaybackSettings.bDisableCameraCuts = true;

// Restaurer la caméra du joueur après la scène cinématique (appeler depuis le délégué OnFinished)
APlayerController* PC = GetWorld()->GetFirstPlayerController();
PC->SetViewTargetWithBlend(PC->GetPawn(), 0.5f, VTBlend_Cubic);
PC->SetIgnoreMoveInput(false);
PC->SetIgnoreLookInput(false);

APlayerCameraManager

APlayerCameraManager (accessible via PlayerController->PlayerCameraManager) gère le mélange de caméra et la sélection de la cible de vue pour le joueur local. Après la fin d'une scène cinématique, restaurez explicitement la caméra de gameplay — le Sequencer ne le fait pas automatiquement :

APlayerController* PC = GetWorld()->GetFirstPlayerController();
// PlayerCameraManager gère l'état de mélange ; SetViewTargetWithBlend le déclenche.
PC->SetViewTargetWithBlend(PC->GetPawn(), 0.5f, VTBlend_Cubic);
// Le mélange est traité à chaque tick dans APlayerCameraManager::UpdateCamera.

Événements Sequencer

Les pistes d'événements appellent des UFUNCTIONs sur les objets du contexte d'événement. Contexte d'événement par défaut : UWorld + ALevelScriptActor.

// La fonction doit être UFUNCTION(BlueprintCallable) sur un objet de contexte
UFUNCTION(BlueprintCallable, Category = "Cinematics")
void TriggerExplosion()
{
    ExplosionSystem->SpawnExplosion(ExplosionLocation);
}

// Déclencher du code C++ à une image spécifique en jouant jusqu'à elle (déclenche tous les événements dans la plage)
Player->PlayTo(
    FMovieSceneSequencePlaybackParams(FFrameTime(60), EUpdatePositionMethod::Play),
    FMovieSceneSequencePlayToParams());

FMovieSceneEvent

FMovieSceneEvent contient les données du point d'extrémité de l'événement — la fonction liée à appeler lorsque l'événement déclenche. Les pistes d'événements sont structurées comme suit :

  • UMovieSceneEventTrack — la piste maîtresse ajoutée à une liaison ou comme piste maîtresse
  • UMovieSceneEventTriggerSection — une section contenant une ou plusieurs entrées de déclenchement
  • FMovieSceneEvent — chaque entrée dans la section de déclenchement, pointant vers la fonction d'extrémité

La fonction d'extrémité est résolue à l'exécution par rapport aux objets du contexte d'événement (par défaut UWorld et ALevelScriptActor). Les événements basés sur le directeur se résolvent par rapport à une instance de sous-classe ULevelSequenceDirector.

ULevelSequenceDirector — Contexte d'Événement Personnalisé

ULevelSequenceDirector fournit un contexte de script par séquence qui reçoit les appels de piste d'événement. Sous-classez-le (Blueprint ou C++) et assignez-le à la propriété Director Class de l'asset LevelSequence. L'instance Director est créée lorsque la séquence commence à jouer et détruite lorsqu'elle s'arrête — sa durée de vie correspond à celle du lecteur de séquence.

// MySequenceDirector.h
#include "LevelSequenceDirector.h"
#include "MySequenceDirector.generated.h"

UCLASS(Blueprintable)
class UMySequenceDirector : public ULevelSequenceDirector
{
    GENERATED_BODY()
public :
    // Appelé depuis les pistes d'événements Sequencer — lier à la touche d'événement dans l'éditeur Sequencer
    UFUNCTION(BlueprintCallable, Category = "Cinematics")
    void OnDialogueStart(FName SpeakerTag);

    UFUNCTION(BlueprintCallable, Category = "Cinematics")
    void OnCutsceneChoice(int32 ChoiceIndex);
};

// MySequenceDirector.cpp
void UMySequenceDirector::OnDialogueStart(FName SpeakerTag)
{
    // Accéder au lecteur de séquence et aux acteurs liés depuis l'intérieur du Director.
    // ULevelSequenceDirector.h : UPROPERTY ULevelSequencePlayer* Player (champ direct, pas de getter)
    TArray<UObject*> Bound = Player->GetBoundObjects(SpeakerBindingID);
    // Déclencher la logique de gameplay : UI, système de dialogue, mise au point de la caméra, etc.
}

Pourquoi Director plutôt que Level Script : Le Director voyage avec l'asset de séquence, pas le niveau. Réutilisable entre les cartes. Prend en charge l'état par séquence (variables membres). Les événements Level Script ne fonctionnent que lorsque la séquence est placée dans ce niveau spécifique.


Pistes MovieScene

// MovieScene.h — obtenez-les depuis l'asset LevelSequence
UMovieScene* MS = SeqActor->GetSequence()->GetMovieScene();

// Possessables (acteurs mondiaux) — itérer par index
for (int32 i = 0; i < MS->GetPossessableCount(); ++i)
{
    const FMovieScenePossessable& P = MS->GetPossessable(i);
}
// Spawnables (acteurs possédés par la séquence) — itérer par index
for (int32 i = 0; i < MS->GetSpawnableCount(); ++i)
{
    const FMovieSceneSpawnable& S = MS->GetSpawnable(i);
}

// Pistes maîtresses (non liées à un acteur)
const TArray<UMovieSceneTrack*>& Masters = MS->GetTracks();

// Pistes sur une liaison spécifique
const FMovieSceneBinding* B = MS->FindBinding(SomeGuid);
if (B) { for (UMovieSceneTrack* T : B->GetTracks()) { /* caster vers le sous-type */ } }
Classe de PisteObjectif
UMovieScene3DTransformTrackAnimation de transformation
UMovieSceneSkeletalAnimationTrackAnimation de maillage squelettique
UMovieSceneEventTrackDéclencheurs d'événements
UMovieSceneAudioTrackAudio
UMovieSceneFadeTrackFondu d'écran
UMovieSceneCameraCutTrackCoupes de caméra
UMovieSceneSubTrackSous-séquences
UMovieScenePropertyTrackAnimation UPROPERTY arbitraire (classe de base)

Tous les types de pistes nécessitent MovieSceneTracks dans Build.cs.

Pistes personnalisées : sous-classez UMovieSceneTrack + UMovieSceneSection pour des données d'animation spécifiques au domaine. Enregistrez via ISequencerModule::RegisterTrackEditor. C'est un modèle avancé — la plupart des besoins sont satisfaits par les sous-classes de UMovieScenePropertyTrack.

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