Ue Sequencer Cinematics

PublicDependencyModuleNames.AddRange(new string[]
{
    "LevelSequence",    // ULevelSequence, ALevelSequenceActor, ULevelSequencePlayer, ULevelSequenceDirector
    "MovieScene",       // UMovieScene, UMovieSceneSequencePlayer, FMovieSceneObjectBindingID
    "MovieSceneTracks", // UMovieSceneEventTrack, UMovieSceneCameraCutTrack, property tracks
    "CinematicCamera",  // ACineCameraActor, UCineCameraComponent, ACameraRig_Rail, ACameraRig_Crane
});

// Offline rendering only. Requires the MovieRenderPipeline plugin enabled in the .uproject.
PrivateDependencyModuleNames.Add("MovieRenderPipelineCore");

#include "LevelSequenceActor.h"

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

#include "LevelSequencePlayer.h"
#include "MovieSceneSequencePlaybackSettings.h"

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

FMovieSceneSequencePlaybackSettings Settings;
Settings.bAutoPlay             = false;
Settings.PlayRate              = 1.0f;
Settings.StartTime             = 0.0f;   // seconds into the playback range
Settings.LoopCount.Value       = 0;      // 0 = once, -1 = infinite, N = N extra loops
Settings.bDisableMovementInput = true;
Settings.bDisableLookAtInput   = true;
Settings.bHidePlayer           = false;
Settings.bHideHud              = true;
Settings.bDisableCameraCuts    = false;
Settings.bPauseAtEnd           = false;
Settings.bDynamicWeighting     = false;  // set true (or enable it on the asset) before using SetWeight() — MovieSceneSequencePlayer.h:278
Settings.FinishCompletionStateOverride = EMovieSceneCompletionModeOverride::ForceRestoreState;

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

ActiveSequenceActor = OutActor;   // UPROPERTY member — otherwise both are collected
ActivePlayer        = Player;     // UPROPERTY member
// Remaining fields: bRandomStartTime, TickInterval, bInheritTickIntervalFromOwner

Player->Play();
Player->PlayReverse();
Player->PlayLooping(-1);          // -1 = infinite
Player->ChangePlaybackDirection();
Player->Pause();
Player->Scrub();
Player->Stop();                   // resets the cursor and fires OnStop
Player->StopAtCurrentTime();
Player->GoToEndAndStop();
Player->SetPlayRate(0.5f);
Player->SetFrameRange(0, 60);     // (StartFrame, Duration) in display-rate frames
Player->SetTimeRange(0.0f, 2.5f); // (StartTime, Duration) in seconds

// Seek without firing the events in between
Player->SetPlaybackPosition(
    FMovieSceneSequencePlaybackParams(FFrameTime(120), EUpdatePositionMethod::Jump));

// Advance to a frame, firing every event along the way
Player->PlayTo(
    FMovieSceneSequencePlaybackParams(FFrameTime(240), EUpdatePositionMethod::Play),
    FMovieSceneSequencePlayToParams());

// Seconds instead of frames: FMovieSceneSequencePlaybackParams(2.5f, EUpdatePositionMethod::Jump)

const bool bPlaying           = Player->IsPlaying();
const FQualifiedFrameTime Now = Player->GetCurrentTime();
const FQualifiedFrameTime Dur = Player->GetDuration();
const FFrameRate Rate         = Player->GetFrameRate();

// UPROPERTY(BlueprintAssignable) FOnMovieSceneSequencePlayerEvent — dynamic, no parameters
Player->OnPlay.AddDynamic(this, &AMyCutsceneManager::HandleSequencePlay);
Player->OnStop.AddDynamic(this, &AMyCutsceneManager::HandleSequenceStop);
Player->OnFinished.AddDynamic(this, &AMyCutsceneManager::HandleSequenceFinished);

Player->OnPause.AddDynamic(this, &AMyCutsceneManager::HandleSequencePause);
Player->OnNativeFinished.BindUObject(this, &AMyCutsceneManager::HandleNativeFinished); // native

// LevelSequencePlayer.h:27 — DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(
//     FOnLevelSequencePlayerCameraCutEvent, UCameraComponent*, CameraComponent)
Player->OnCameraCut.AddDynamic(this, &AMyCutsceneManager::HandleCameraCut);

#include "LevelSequenceActor.h"
#include "MovieSceneObjectBindingID.h"

// LevelSequenceActor.h:178-253
SeqActor->SetBindingByTag(FName("Hero"), TArray<AActor*>{ HeroActor },
                          /*bAllowBindingsFromAsset=*/ false);
SeqActor->AddBindingByTag(FName("Crowd"), ExtraActor, /*bAllowBindingsFromAsset=*/ true);
SeqActor->RemoveBindingByTag(FName("Crowd"), ExtraActor);

// GUID form — expose the ID so a designer can pick the binding in the details panel:
// UPROPERTY(EditAnywhere, Category = "Cinematics") FMovieSceneObjectBindingID HeroBindingID;
SeqActor->SetBinding(HeroBindingID, TArray<AActor*>{ HeroActor }, false);
SeqActor->AddBinding(HeroBindingID, HeroActor, false);
SeqActor->RemoveBinding(HeroBindingID, HeroActor);
SeqActor->ResetBinding(HeroBindingID);   // back to whatever the asset says
SeqActor->ResetBindings();               // clear every override

const FMovieSceneObjectBindingID Found = SeqActor->FindNamedBinding(FName("Hero"));
const TArray<FMovieSceneObjectBindingID>& All = SeqActor->FindNamedBindings(FName("Crowd"));

// What is actually bound right now
TArray<UObject*> Bound = Player->GetBoundObjects(HeroBindingID);

#include "DefaultLevelSequenceInstanceData.h"

UDefaultLevelSequenceInstanceData* Data =
    NewObject<UDefaultLevelSequenceInstanceData>(SeqActor);
Data->TransformOriginActor = StageMarkerActor;   // or leave null and set TransformOrigin
SeqActor->DefaultInstanceData  = Data;
SeqActor->bOverrideInstanceData = true;

// MyCinematicDirector.h
#pragma once

#include "LevelSequenceDirector.h"
#include "MovieSceneObjectBindingID.h"
#include "MyCinematicDirector.generated.h"

class AActor;

UCLASS(Blueprintable)
class MYGAME_API UMyCinematicDirector : public ULevelSequenceDirector
{
    GENERATED_BODY()

public:
    /** Event endpoint with no parameters. */
    UFUNCTION(BlueprintCallable, CallInEditor, Category = "Cinematics")
    void OnExplosionCue();

    /** Event endpoint on an object-binding track: receives the bound actor. */
    UFUNCTION(BlueprintCallable, CallInEditor, Category = "Cinematics")
    void OnActorCue(AActor* BoundActor);

    /** Assign in the Director Blueprint's class defaults using the Get Sequence Binding node. */
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Cinematics")
    FMovieSceneObjectBindingID HeroBinding;
};

// MyCinematicDirector.cpp
#include "MyCinematicDirector.h"
#include "LevelSequencePlayer.h"
#include "GameFramework/Actor.h"

void UMyCinematicDirector::OnExplosionCue()
{
    // GetBoundObjects and Player are both declared on ULevelSequenceDirector.
    for (UObject* Object : GetBoundObjects(HeroBinding))
    {
        if (AActor* Hero = Cast<AActor>(Object))
        {
            Hero->SetActorHiddenInGame(true);
        }
    }

    if (Player)
    {
        Player->SetPlayRate(0.25f);
    }
}

void UMyCinematicDirector::OnActorCue(AActor* BoundActor)
{
    if (BoundActor)
    {
        BoundActor->SetActorTickEnabled(false);
    }
}

#include "MovieScene.h"
#include "MovieSceneSpawnable.h"
#include "MovieScenePossessable.h"

UMovieScene* MS = SeqActor->GetSequence()->GetMovieScene();

const FFrameRate DisplayRate     = MS->GetDisplayRate();
const FFrameRate TickResolution  = MS->GetTickResolution();
const TRange<FFrameNumber> Range = MS->GetPlaybackRange();

for (int32 Index = 0; Index < MS->GetPossessableCount(); ++Index)
{
    const FMovieScenePossessable& Possessable = MS->GetPossessable(Index);
    const FGuid Guid = Possessable.GetGuid();       // also GetName, GetPossessedObjectClass
}
for (int32 Index = 0; Index < MS->GetSpawnableCount(); ++Index)
{
    const FMovieSceneSpawnable& Spawnable = MS->GetSpawnable(Index);   // GetGuid, GetName
}

const TArray<UMovieSceneTrack*>& RootTracks = MS->GetTracks();
if (const FMovieSceneBinding* Binding = MS->FindBinding(SomeGuid))
{
    for (UMovieSceneTrack* Track : Binding->GetTracks()) { /* Cast to a concrete type */ }
}

#include "Tracks/MovieSceneSubTrack.h"
#include "Sections/MovieSceneSubSection.h"

UMovieSceneSubTrack* SubTrack = RootMovieScene->AddTrack<UMovieSceneSubTrack>();
const FFrameNumber Start = (2.0 * RootMovieScene->GetTickResolution()).FloorToFrame();
const int32 Duration = (5.0 * RootMovieScene->GetTickResolution()).FloorToFrame().Value;

UMovieSceneSubSection* SubSection = SubTrack->AddSequence(ChildSequence, Start, Duration);
SubSection->Parameters.TimeScale.Set(1.0);   // FMovieSceneTimeWarpVariant — Set(), not assignment
SubSection->Parameters.bCanLoop = false;
SubSection->Parameters.StartFrameOffset = FFrameNumber(0);

#include "CineCameraActor.h"
#include "CineCameraComponent.h"
#include "CineCameraSettings.h"

ACineCameraActor* Cam = GetWorld()->SpawnActor<ACineCameraActor>(SpawnLocation, SpawnRotation);
UCineCameraComponent* CineComp = Cam->GetCineCameraComponent();

FCameraFilmbackSettings Filmback;          // SensorWidth / SensorHeight in mm
Filmback.SensorWidth  = 36.0f;
Filmback.SensorHeight = 24.0f;
CineComp->SetFilmback(Filmback);           // SensorAspectRatio is derived, not settable

FCameraLensSettings Lens;                  // mm and f-stops
Lens.MinFocalLength       = 35.0f;
Lens.MaxFocalLength       = 35.0f;
Lens.MinFStop             = 1.4f;
Lens.MaxFStop             = 16.0f;
Lens.MinimumFocusDistance = 30.0f;
Lens.DiaphragmBladeCount  = 7;
CineComp->SetLensSettings(Lens);

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

CineComp->SetCurrentFocalLength(35.0f);    // mm; UPROPERTY(Interp) so Sequencer can key it
CineComp->SetCurrentAperture(2.0f);        // f-stop; also Interp

Cam->LookatTrackingSettings.bEnableLookAtTracking     = true;
Cam->LookatTrackingSettings.ActorToTrack              = TargetActor;  // TSoftObjectPtr<AActor>
Cam->LookatTrackingSettings.RelativeOffset            = FVector(0.f, 0.f, 80.f);
Cam->LookatTrackingSettings.LookAtTrackingInterpSpeed = 4.0f;

#include "CameraRig_Rail.h"
#include "CameraRig_Crane.h"

Rail->CurrentPositionOnRail  = 0.35f;   // 0..1 along the spline
Rail->bLockOrientationToRail = true;
USplineComponent* RailSpline = Rail->GetRailSplineComponent();

Crane->CraneArmLength  = 400.0f;        // cm
Crane->CranePitch      = 12.0f;         // degrees
Crane->CraneYaw        = -45.0f;
Crane->bLockMountPitch = true;          // also bLockMountYaw