Level / Master Sequence in Unreal Engine

/**
 * <mark>Load Level Sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	Error message in a case of bOutSuccess == false
 * @return The loaded ULevelSequence*
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=ms-EuSgWEiA" target="_blank">Add Remove Actor From Level Sequence</a>")
<strong>static ULevelSequence* LoadLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence

ULevelSequence* UExampleClass::LoadLevelSequence(FString LevelSequencePath, bool &bOutSuccess, FString &OutInfoMsg)
{
  ULevelSequence* LevelSequence = Cast<ULevelSequence>(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));
  bOutSuccess = (LevelSequence != nullptr);
  if (!bOutSuccess) OutInfoMsg = FString::Printf(TEXT("Get Level Sequence at path '%s' Failed - Level Sequence isn't valid."), *LevelSequencePath);
  <strong>return LevelSequence;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
  }
);

/**
 * <mark>Get actor guid from level sequence</mark>
 *
 * @param Actor		The actor to get from the level sequence
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The guid of the actor in the level sequence
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=ms-EuSgWEiA" target="_blank">Add Remove Actor From Level Sequence</a>")
<strong>static FGuid GetActorGuidFromLevelSequence(AActor* Actor, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

FGuid UExampleClass::GetActorGuidFromLevelSequence(AActor* Actor, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Validate Actor
	if (Actor == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Get Actor Guid From Level Sequence Failed - Actor isn't valid. '%s'"), *LevelSequencePath);
		return FGuid();
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return FGuid();
	
	// Get Actor Guid from Level Sequence
	FGuid Guid = LevelSequence-&gt;FindBindingFromObject(Actor, Actor-&gt;GetWorld());
	bOutSuccess = Guid.IsValid();
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Actor Guid From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return Guid;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Add an actor into a level sequence</mark>
 *
 * @param Actor		The actor to add in the level sequence
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 * 
 * @return The guid of the actor in the level sequence
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=ms-EuSgWEiA" target="_blank">Add Remove Actor From Level Sequence</a>")
<strong>static FGuid AddActorIntoLevelSequence(AActor* Actor, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

FGuid UExampleClass::AddActorIntoLevelSequence(AActor* Actor, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get Actor Guid
	FGuid Guid = <a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (Guid.IsValid())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Actor Into Level Sequence Failed - Actor is already in the level sequence. '%s'"), *LevelSequencePath);
		return Guid;
	}

	// Validate Actor
	if (Actor == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Actor Into Level Sequence Failed - Actor isn't valid. '%s'"), *LevelSequencePath);
		return FGuid();
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return FGuid();

	// <mark>Create Actor Track into Level Sequence and link it with the Actor</mark>
	Guid = Cast&lt;UMovieSceneSequence&gt;(LevelSequence)-&gt;CreatePossessable(Actor);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Actor Into Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return Guid;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Remove an actor from a level sequence</mark>
 *
 * @param Actor		The actor to remove from the level sequence
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param OutInfoMsg	More information about the action's result
 * @param return If the action was a success or not
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=ms-EuSgWEiA" target="_blank">Add Remove Actor From Level Sequence</a>")
<strong>static bool RemoveActorFromLevelSequence(AActor* Actor, FString LevelSequencePath, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

bool UExampleClass::RemoveActorFromLevelSequence(AActor* Actor, FString LevelSequencePath, FString& OutInfoMsg)
{
	bool bOutSuccess;
	// Get Actor Guid
	FGuid Guid = <a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return false;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return false;
	
	// Unbind Track from Actor
	LevelSequence-&gt;UnbindPossessableObjects(Guid);

	// Remove Actor Track from Level Sequence
	bOutSuccess = LevelSequence-&gt;MovieScene-&gt;RemovePossessable(Guid);

	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Remove Actor From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return bOutSuccess</strong>;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * Get spawnable guid from level sequence based on its name
 *
 * @param SpawnableName		The name of the spawnable once in the sequencer (used to identify it)
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The guid of the spawnable in the level sequence
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3xuwSeyc0Fk" target="_blank">Add Remove Spawnable From Level Sequence</a>")
<strong>static FGuid GetSpawnableGuidFromLevelSequence(FString SpawnableName, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

FGuid UExampleClass::GetSpawnableGuidFromLevelSequence(FString SpawnableName, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return FGuid();

	// Get Spawnable Guid from Level Sequence
	FGuid Guid = FGuid();
	for (int X = 0; X &lt; LevelSequence-&gt;MovieScene-&gt;GetSpawnableCount(); X++)
	{
		FMovieSceneSpawnable Spawnable = LevelSequence-&gt;MovieScene-&gt;GetSpawnable(X);
		FString Name = LevelSequence-&gt;MovieScene-&gt;GetObjectDisplayName(Spawnable.GetGuid()).ToString();
		if (Name == SpawnableName)
		{
			Guid = Spawnable.GetGuid();
			break;
		}
	}

	bOutSuccess = Guid.IsValid();
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Spawnable Guid From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return Guid;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Add a spawnable into a level sequence</mark>
 *
 * @param SpawnableName		The name of the spawnable once in the sequencer (used to identify it)
 * @param AssetPath		The path of the asset to spawn in the level sequence: "/Game/Folder/MyStaticMesh"
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 * 
 * @return The guid of the actor in the level sequence
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3xuwSeyc0Fk" target="_blank">Add Remove Spawnable From Level Sequence</a>")
<strong>static FGuid AddSpawnableIntoLevelSequence(FString SpawnableName, FString AssetPath, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

FGuid UExampleClass::AddSpawnableIntoLevelSequence(FString SpawnableName, FString AssetPath, FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get Spawnable Guid
	FGuid Guid = GetSpawnableGuidFromLevelSequence(SpawnableName, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (Guid.IsValid())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Spawnable Into Level Sequence Failed - Spawnable is already in the level sequence. '%s'"), *LevelSequencePath);
		return Guid;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return FGuid();

	// Validate asset to use as a spawnable
	UObject* SpawnableTemplate = Cast&lt;UObject&gt;(StaticLoadObject(UObject::StaticClass(), nullptr, *AssetPath));
	if (SpawnableTemplate == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Spawnable Into Level Sequence Failed - Spawnable template isn't valid. '%s'"), *LevelSequencePath);
		return FGuid();
	}

	// Create Spawnable Track in Level Sequence
	Guid = Cast&lt;UMovieSceneSequence&gt;(LevelSequence)-&gt;CreateSpawnable(SpawnableTemplate);
	if (!Guid.IsValid())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Spawnable Into Level Sequence Failed - Cannot add asset in level sequence. '%s'"), *AssetPath);
		return FGuid();
	}

	// Rename the Spawnable to be able to find it later
	LevelSequence-&gt;MovieScene-&gt;SetObjectDisplayName(Guid, FText::FromString(SpawnableName));

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Spawnable Into Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return Guid;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Remove a spawnable from a level sequence</mark>
 *
 * @param SpawnableName		The name of the spawnable in the sequencer (used to identify it)
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 * @param return	If the action was a success or not
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3xuwSeyc0Fk" target="_blank">Add Remove Spawnable From Level Sequence</a>")
<strong>static bool RemoveSpawnableFromLevelSequence(FString SpawnableName, FString LevelSequencePath, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene

bool UExampleClass::RemoveSpawnableFromLevelSequence(FString SpawnableName, FString LevelSequencePath, FString& OutInfoMsg)
{
	// Get Spawnable Guid
	FGuid Guid = GetSpawnableGuidFromLevelSequence(SpawnableName, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return false
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return false;

	// Remove Spawnable from Level Sequence
	bool bOutSuccess = LevelSequence-&gt;MovieScene-&gt;RemoveSpawnable(Guid);
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Remove Spawnable From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return true</strong>;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * Add an animation to an actor in a level sequence
 *
 * @param Actor		The actor in the level sequence
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param AnimationPath		The path of the animation to assign to the actor: "/Game/Folder/MyAnimation"
 * @param StartFrame	Start frame of the animation section in the level sequence
 * @param EndFrame	End frame of the animation section in the level sequence
 * @param OutInfoMsg	More information about the action's result
 * @param return	If the action was a success or not
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=OSwqooOwTls" target="_blank">Add Animation In Level Sequence</a>")
<strong>static bool AddAnimationInLevelSequence(AActor* Actor, FString LevelSequencePath, FString AnimationPath, int StartFrame, int EndFrame, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneSkeletalAnimationTrack.h" // MovieSceneTracks
#include "MovieSceneSection.h" // MovieScene

void UExampleClass::AddAnimationInLevelSequence(AActor* Actor, FString LevelSequencePath, FString AnimationPath, int StartFrame, int EndFrame, FString& OutInfoMsg)
{
	// Load Animation
	UAnimSequence* Animation = Cast<UAnimSequence>(StaticLoadObject(UAnimSequence::StaticClass(), nullptr, *AnimationPath));
	if (Animation == nullptr)
	{
		OutInfoMsg = FString::Printf(TEXT("Add Animation To Actor In Level Sequence Failed - Animation isn't valid. '%s'"), *AnimationPath);
		return false;
	}

	// Get Actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return false;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return false;

	// Find Track on which to add the Animation
	UMovieSceneSkeletalAnimationTrack* AnimTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneSkeletalAnimationTrack&gt;(Guid);
	if (AnimTrack == nullptr)
	{
		// Create Track if doesn't exist
		AnimTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneSkeletalAnimationTrack&gt;(Guid);
		if (AnimTrack == nullptr)
		{
			OutInfoMsg = FString::Printf(TEXT("Add Animation To Actor In Level Sequence Failed - Was not able to create Track '%s'"), *LevelSequencePath);
			return false;
		}
	}

	// Calculate the Tick Value for the input frame numbers. <mark>Level Sequence works in ticks</mark>, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int FrameTickValue = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();

	// Add Animation on Track
	UMovieSceneSection* Section = AnimTrack-&gt;AddNewAnimation(FFrameNumber(StartFrame * FrameTickValue), Animation);
	if (Section == nullptr)
	{
		OutInfoMsg = FString::Printf(TEXT("Add Animation To Actor In Level Sequence Failed - Was not able to create Section '%s'"), *LevelSequencePath);
		return false;
	}

	// Set end frame
	if (EndFrame &gt; StartFrame)
	{
		Section-&gt;SetEndFrame(FFrameNumber(EndFrame * FrameTickValue));
	}

	// Update the tracks in the Level Sequence
	AnimTrack-&gt;Modify();

	OutInfoMsg = FString::Printf(TEXT("Add Animation To Actor In Level Sequence Succeeded - '%s'
'%s'"), *AnimationPath, *LevelSequencePath);
	<strong>return true;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>"MovieSceneTracks"</mark>,
  }
);

/**
 * <mark>Get a camera cut track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 * 
 * @return The camera cut track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=UUeFLChFT_U" target="_blank">Add Remove Camera Cut Track From Level Sequence</a>")
<strong>static class UMovieSceneCameraCutTrack* GetCameraCutTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCameraCutTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneCameraCutSection.h" // MovieScene
#include "Camera/CameraActor.h" // Engine

UMovieSceneCameraCutTrack* UExampleClass::GetCameraCutTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return FGuid();

	// Get the camera cut track
	UMovieSceneCameraCutTrack* CameraCutTrack = Cast&lt;UMovieSceneCameraCutTrack&gt;(LevelSequence-&gt;MovieScene-&gt;GetCameraCutTrack());
	bOutSuccess = CameraCutTrack != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Camera Cut Track From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return CameraCutTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>"MovieSceneTracks"</mark>,
  }
);

/**
 * <mark>Add a camera cut track to a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 * 
 * @return The camera cut track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=UUeFLChFT_U" target="_blank">Add Remove Camera Cut Track From Level Sequence</a>")
<strong>static class UMovieSceneCameraCutTrack* AddCameraCutTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCameraCutTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneCameraCutSection.h" // MovieScene
#include "Camera/CameraActor.h" // Engine

UMovieSceneCameraCutTrack* UExampleClass::AddCameraCutTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a camera cut track in the level sequence
	UMovieSceneCameraCutTrack* CameraCutTrack = <a href="#GetCameraCutTrackFromLevelSequence">GetCameraCutTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (CameraCutTrack != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Camera Cut Track In Level Sequence Failed - Track already in level sequence. '%s'"), *LevelSequencePath);
		return CameraCutTrack;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Add track
	CameraCutTrack = Cast&lt;UMovieSceneCameraCutTrack&gt;(LevelSequence-&gt;MovieScene-&gt;AddCameraCutTrack(UMovieSceneCameraCutTrack::StaticClass()));
	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Camera Cut Track In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return CameraCutTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>"MovieSceneTracks"</mark>,
  }
);

	/**
 * <mark>Remove a camera cut track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param OutInfoMsg		More information about the action's result
 * @param return	If the action was a success or not
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=UUeFLChFT_U" target="_blank">Add Remove Camera Cut Track From Level Sequence</a>")
<strong>static bool RemoveCameraCutTrackFromLevelSequence(FString LevelSequencePath, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCameraCutTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneCameraCutSection.h" // MovieScene
#include "Camera/CameraActor.h" // Engine

bool UExampleClass::RemoveCameraCutTrackFromLevelSequence(FString LevelSequencePath, FString& OutInfoMsg)
{
	bool bOutSuccess;

	// Check if there's a camera cut track in the level sequence
	UMovieSceneCameraCutTrack* CameraCutTrack = <a href="#GetCameraCutTrackFromLevelSequence">GetCameraCutTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (CameraCutTrack == nullptr) return false;

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return false;

	// Remove track
	LevelSequence-&gt;MovieScene-&gt;RemoveCameraCutTrack();

	OutInfoMsg = FString::Printf(TEXT("Remove Camera Cut Track From Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	return true;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>"MovieSceneTracks"</mark>,
  }
);

/**
 * <mark>Link a camera to a camera cut track in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param CameraActor	The camera actor to link to the track
 * @param StartFrame	Start frame of the camera section in the level sequence
 * @param EndFrame	End frame of the camera section in the level sequence
 * @param OutInfoMsg	More information about the action's result
 * @param return	If the action was a success or not
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=UUeFLChFT_U" target="_blank">Add Remove Camera Cut Track From Level Sequence</a>")
<strong>static bool LinkCameraToCameraCutTrack(FString LevelSequencePath, class ACameraActor* CameraActor, int StartFrame, int EndFrame, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCameraCutTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneCameraCutSection.h" // MovieScene
#include "Camera/CameraActor.h" // Engine

bool UExampleClass::LinkCameraToCameraCutTrack(FString LevelSequencePath, ACameraActor* CameraActor, int StartFrame, int EndFrame, FString& OutInfoMsg)
{
	bool bOutSuccess;

	// Make sure camera is valid
	if (CameraActor == nullptr)
	{
		OutInfoMsg = FString::Printf(TEXT("Link Camera To Camera Cut Track Failed - Camera actor isn't valid. '%s'"), *LevelSequencePath);
		return false;
	}

	// Check if there's a camera cut track in the level sequence
	UMovieSceneCameraCutTrack* CameraCutTrack = <a href="#GetCameraCutTrackFromLevelSequence">GetCameraCutTrackFromLevelSequence</a>GetCameraCutTrackFromLevelSequence(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (CameraCutTrack == nullptr)
	{
		OutInfoMsg = FString::Printf(TEXT("Link Camera To Camera Cut Track Failed - Camera cut track isn't valid. '%s'"), *LevelSequencePath);
		return false;
	}

	// Add camera actor in level sequence
	FGuid Guid = UExampleClass::<a href="#AddActorIntoLevelSequence">AddActorIntoLevelSequence</a>(CameraActor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid())
	{
		OutInfoMsg = FString::Printf(TEXT("Link Camera To Camera Cut Track Failed - Failed to add camera actor in level sequence. '%s'"), *LevelSequencePath);
		return false;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return false;

	// Calculate the Tick Value for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int FrameTickValue = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();

	// Link camera to camera cut track
	UMovieSceneCameraCutSection* Section = CameraCutTrack-&gt;AddNewCameraCut(UE::MovieScene::FRelativeObjectBindingID(Guid), FFrameNumber(StartFrame * FrameTickValue));
	if (Section == nullptr)
	{
		OutInfoMsg = FString::Printf(TEXT("Link Camera To Camera Cut Track Failed - Was not able to create Section '%s'"), *LevelSequencePath);
		return flase;
	}

	// Set end frame
	if (EndFrame &gt; StartFrame) Section-&gt;SetEndFrame(FFrameNumber(EndFrame * FrameTickValue));
	
	OutInfoMsg = FString::Printf(TEXT("Link Camera To Camera Cut Track Succeeded - '%s'"), *LevelSequencePath);
	return true;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>"MovieSceneTracks"</mark>,
  }
);

/**
 * <mark>Get a folder from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param FolderName	The name of the folder
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 * 
 * @return The folder
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=dSwrrDCihyw" target="_blank">Add Remove Folder From Level Sequence</a>")
<strong>static class UMovieSceneFolder* GetFolderFromLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneFolder.h" // MovieScene

UMovieSceneFolder* UExampleClass::GetFolderFromLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;
	
	// Find existing folder
	UMovieSceneFolder* ExistingFolder = nullptr;
	for (UMovieSceneFolder* Folder : LevelSequence-&gt;MovieScene-&gt;GetRootFolders())
	{
		if (Folder-&gt;GetFolderName().ToString() == FolderName)
		{
			ExistingFolder = Folder;
			break;
		}
	}
	bOutSuccess = ExistingFolder != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Folder From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return ExistingFolder;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
* <mark>Add a folder to a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param FolderName	The name of the folder
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 * 
 * @return The folder
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=dSwrrDCihyw" target="_blank">Add Remove Folder From Level Sequence</a>")
<strong>static class UMovieSceneFolder* AddFolderInLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneFolder.h" // MovieScene
	
UMovieSceneFolder* UExampleClass::AddFolderInLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check for existing folder
	UMovieSceneFolder* Folder = <a href="#GetFolderFromLevelSequence">GetFolderFromLevelSequence</a>(LevelSequencePath, FolderName, bOutSuccess, OutInfoMsg);
	if (Folder != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Folder In Level Sequence Failed - Folder already exists. '%s'
'%s'"), *FolderName, *LevelSequencePath);
		return Folder;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Create folder
	Folder = NewObject&lt;UMovieSceneFolder&gt;(LevelSequence-&gt;MovieScene, NAME_None, RF_Transactional);
	Folder-&gt;SetFolderName(*FolderName);
	
	// Add folder in level sequence
	LevelSequence-&gt;MovieScene-&gt;AddRootFolder(Folder);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Folder In Level Sequence Succeeded - '%s'
'%s'"), *FolderName, *LevelSequencePath);
	<strong>return Folder;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Remove a folder from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param FolderName	The name of the folder
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=dSwrrDCihyw" target="_blank">Add Remove Folder From Level Sequence</a>")
<strong>static void RemoveFolderFromLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneFolder.h" // MovieScene
void UExampleClass::RemoveFolderFromLevelSequence(FString LevelSequencePath, FString FolderName, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check for existing folder
	UMovieSceneFolder* Folder = <a href="#GetFolderFromLevelSequence">GetFolderFromLevelSequence</a>(LevelSequencePath, FolderName, bOutSuccess, OutInfoMsg);
	if (Folder == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Folder From Level Sequence Failed - Folder doesn't exist. '%s'
'%s'"), *FolderName, *LevelSequencePath);
		return;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Remove folder from level sequence
	LevelSequence-&gt;MovieScene-&gt;RemoveRootFolder(Folder);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Folder From Level Sequence Succeeded - '%s'
'%s'"), *FolderName, *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Move an actor in a folder in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param FolderName	The name of the folder
 * @param Actor		The actor to move into the folder
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=dSwrrDCihyw" target="_blank">Add Remove Folder From Level Sequence</a>")
<strong>static void MoveActorInFolderInLevelSequence(FString LevelSequencePath, FString FolderName, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneFolder.h" // MovieScene
void UExampleClass::MoveActorInFolderInLevelSequence(FString LevelSequencePath, FString FolderName, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get folder
	UMovieSceneFolder* Folder = <a href="#GetFolderFromLevelSequence">GetFolderFromLevelSequence</a>(LevelSequencePath, FolderName, bOutSuccess, OutInfoMsg);
	if (Folder == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor In Folder In Level Sequence Failed - Folder doesn't exist. '%s'
'%s'"), *FolderName, *LevelSequencePath);
		return;
	}

	// Get actor from level sequence
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor In Folder In Level Sequence Failed - Actor is not in level sequence. '%s'"), *LevelSequencePath);
		return;
	}

	// Is the actor in the folder
	if (Folder-&gt;GetChildObjectBindings().Contains(Guid))
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor In Folder In Level Sequence Failed - Actor is already in folder. '%s'"), *LevelSequencePath);
		return;
	}

	// Move actor in folder
	Folder-&gt;AddChildObjectBinding(Guid);
	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Move Actor In Folder In Level Sequence Succeeded - '%s'
'%s'"), *FolderName, *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Move an actor out of a folder in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param FolderName	The name of the folder
 * @param Actor		The actor to move out of the folder
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=dSwrrDCihyw" target="_blank">Add Remove Folder From Level Sequence</a>")
<strong>static void MoveActorOutOfFolderInLevelSequence(FString LevelSequencePath, FString FolderName, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneFolder.h" // MovieScene
void UExampleClass::MoveActorOutOfFolderInLevelSequence(FString LevelSequencePath, FString FolderName, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get folder
	UMovieSceneFolder* Folder = <a href="#GetFolderFromLevelSequence">GetFolderFromLevelSequence</a>(LevelSequencePath, FolderName, bOutSuccess, OutInfoMsg);
	if (Folder == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor Out Of Folder In Level Sequence Failed - Folder doesn't exist. '%s'
'%s'"), *FolderName, *LevelSequencePath);
		return;
	}

	// Get actor from level sequence
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor Out Of Folder In Level Sequence Failed - Actor is not in level sequence. '%s'"), *LevelSequencePath);
		return;
	}

	// Is the actor in the folder
	if (!Folder-&gt;GetChildObjectBindings().Contains(Guid))
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Move Actor Out Of Folder In Level Sequence Failed - Actor is not in folder. '%s'"), *LevelSequencePath);
		return;
	}
	
	// Move actor out of folder
	Folder-&gt;RemoveChildObjectBinding(Guid);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Move Actor Out Of Folder In Level Sequence Succeeded - '%s'
'%s'"), *FolderName, *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Get a shot track from a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The shot track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=aGOJoMptzrA" target="_blank">Shot Track in Level Sequence</a>")
<strong>static class UMovieSceneCinematicShotTrack* GetShotTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCinematicShotTrack.h" // MovieSceneTracks

UMovieSceneCinematicShotTrack* UExampleClass::GetShotTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Get the shot track
	UMovieSceneCinematicShotTrack* ShotTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneCinematicShotTrack&gt;();
	bOutSuccess = ShotTrack != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Shot Track From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
	<strong>return ShotTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Add a shot track to a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The shot track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=aGOJoMptzrA" target="_blank">Shot Track in Level Sequence</a>")
<strong>static class UMovieSceneCinematicShotTrack* AddShotTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCinematicShotTrack.h" // MovieSceneTracks

UMovieSceneCinematicShotTrack* UExampleClass::AddShotTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a shot track in the level sequence
	UMovieSceneCinematicShotTrack* ShotTrack = <a href="#GetShotTrackFromLevelSequence">GetShotTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (ShotTrack != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Shot Track In Level Sequence Failed - Track already in level sequence. '%s'"), *LevelSequencePath);
		return ShotTrack;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Add track
	ShotTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneCinematicShotTrack&gt;();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Shot Track In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return ShotTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a shot track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=aGOJoMptzrA" target="_blank">Shot Track in Level Sequence</a>")
<strong>static void RemoveShotTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCinematicShotTrack.h" // MovieSceneTracks

void UExampleClass::RemoveShotTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a shot track in the level sequence
	UMovieSceneCinematicShotTrack* ShotTrack = <a href="#GetShotTrackFromLevelSequence">GetShotTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (ShotTrack == nullptr) return;
	

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Remove track
	LevelSequence-&gt;MovieScene-&gt;RemoveTrack(*ShotTrack);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Shot Track From Level Sequence Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Link a level sequence to a shot track in a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Shot	The level sequence to link to the track as a shot
 * @param StartFrame	Start frame of the shot section in the level sequence
 * @param EndFrame	End frame of the shot section in the level sequence
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=aGOJoMptzrA" target="_blank">Shot Track in Level Sequence</a>")
<strong>static void LinkShotToShotTrack(FString LevelSequencePath, class ULevelSequence* Shot, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneCinematicShotTrack.h" // MovieSceneTracks

void UExampleClass::LinkShotToShotTrack(FString LevelSequencePath, ULevelSequence* Shot, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Make sure level sequence is valid
	if (Shot == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Link Shot To Shot Track Failed - Shot isn't valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Check if there's a shot track in the level sequence
	UMovieSceneCinematicShotTrack* ShotTrack = GetShotTrackFromLevelSequence(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (ShotTrack == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Link Shot To Shot Track Failed - Shot track isn't valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence->MovieScene->GetDisplayRate().AsDecimal();

	// Link shot to shot track
	UMovieSceneSubSection* Section = ShotTrack-&gt;AddSequence(Shot, FFrameNumber(StartFrame * TicksPerFrame), (EndFrame - StartFrame) * TicksPerFrame);
	
	bOutSuccess = Section != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Link Shot To Shot Track %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Get a subsequence track from a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The subsequence track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=YFtd8F1ahtI" target="_blank">Subsequence In Level Sequence</a>")
<strong>static class UMovieSceneSubTrack* GetSubsequenceTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneSubTrack.h" // MovieScene

UMovieSceneSubTrack* UExampleClass::GetSubsequenceTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Get the Subsequence track
	UMovieSceneSubTrack* SubsequenceTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneSubTrack&gt;();
	bOutSuccess = SubsequenceTrack != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Subsequence Track From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);

	<strong>return SubsequenceTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Add a subsequence track to a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 *
 * @return The subsequence track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=YFtd8F1ahtI" target="_blank">Subsequence In Level Sequence</a>")
<strong>static class UMovieSceneSubTrack* AddSubsequenceTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneSubTrack.h" // MovieScene

UMovieSceneSubTrack* UExampleClass::AddSubsequenceTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a Subsequence track in the level sequence
	UMovieSceneSubTrack* SubsequenceTrack = <a href="#GetSubsequenceTrackFromLevelSequence">GetSubsequenceTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (SubsequenceTrack != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Subsequence Track In Level Sequence Failed - Track already in level sequence. '%s'"), *LevelSequencePath);
		<strong>return SubsequenceTrack;</strong>
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Add track
	SubsequenceTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneSubTrack&gt;();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Subsequence Track In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return SubsequenceTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Remove a subsequence track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=YFtd8F1ahtI" target="_blank">Subsequence In Level Sequence</a>")
<strong>static void RemoveSubsequenceTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneSubTrack.h" // MovieScene

void UExampleClass::RemoveSubsequenceTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a Subsequence track in the level sequence
	UMovieSceneSubTrack* SubsequenceTrack = <a href="#GetSubsequenceTrackFromLevelSequence">GetSubsequenceTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (SubsequenceTrack == nullptr) return;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Remove track
	LevelSequence-&gt;MovieScene-&gt;RemoveTrack(*SubsequenceTrack);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Subsequence Track From Level Sequence Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Link a level sequence to a subsequence track in a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Subsequence	The level sequence to link to the track as a subsequence
 * @param StartFrame	Start frame of the subsequence section in the level sequence
 * @param EndFrame	End frame of the subsequence section in the level sequence
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=YFtd8F1ahtI" target="_blank">Subsequence In Level Sequence</a>")
<strong>static void LinkSequenceToSubsequenceTrack(FString LevelSequencePath, ULevelSequence* Sequence, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneSubTrack.h" // MovieScene

void UExampleClass::LinkSequenceToSubsequenceTrack(FString LevelSequencePath, ULevelSequence* Sequence, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Make sure level sequence is valid
	if (Sequence == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Link Sequence To Subsequence Track Failed - Sequence isn't valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Check if there's a Subsequence track in the level sequence
	UMovieSceneSubTrack* SubsequenceTrack = <a href="#GetSubsequenceTrackFromLevelSequence">GetSubsequenceTrackFromLevelSequence</a>GetSubsequenceTrackFromLevelSequence(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (SubsequenceTrack == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Link Subsequence To Subsequence Track Failed - Subsequence track isn't valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();

	// Link Subsequence to Subsequence track
	UMovieSceneSubSection* Section = SubsequenceTrack-&gt;AddSequence(Sequence, FFrameNumber(StartFrame * TicksPerFrame), (EndFrame - StartFrame) * TicksPerFrame);
	
	bOutSuccess = Section != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Link Sequence To Subsequence Track %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
  }
);

/**
 * <mark>Get a level visibility track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The level visibility track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=sZX98hpPIp8" target="_blank">Level Visibility Track In Level Sequence</a>")
<strong>static class UMovieSceneLevelVisibilityTrack* GetLevelVisibilityTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneLevelVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneLevelVisibilitySection.h" // MovieSceneTracks

UMovieSceneLevelVisibilityTrack* UExampleClass::GetLevelVisibilityTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Get the level visibility track
	UMovieSceneLevelVisibilityTrack* LevelVisibilityTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneLevelVisibilityTrack&gt;();
	bOutSuccess = LevelVisibilityTrack != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Level Visibility Track From Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);

	<strong>return LevelVisibilityTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Add a level visibility track to a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The level visibility track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=sZX98hpPIp8" target="_blank">Level Visibility Track In Level Sequence</a>")
<strong>static class UMovieSceneLevelVisibilityTrack* AddLevelVisibilityTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneLevelVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneLevelVisibilitySection.h" // MovieSceneTracks

UMovieSceneLevelVisibilityTrack* UExampleClass::AddLevelVisibilityTrackInLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a level visibility track in the level sequence
	UMovieSceneLevelVisibilityTrack* LevelVisibilityTrack = <a href="#GetLevelVisibilityTrackFromLevelSequence">GetLevelVisibilityTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelVisibilityTrack != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Level Visibility Track In Level Sequence Failed - Track already in level sequence. '%s'"), *LevelSequencePath);
		return LevelVisibilityTrack;
	}

	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Add track
	LevelVisibilityTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneLevelVisibilityTrack&gt;();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Level Visibility Track In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	return LevelVisibilityTrack;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a level visibility track from a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=sZX98hpPIp8" target="_blank">Level Visibility Track In Level Sequence</a>")
<strong>static void RemoveLevelVisibilityTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneLevelVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneLevelVisibilitySection.h" // MovieSceneTracks

void UExampleClass::RemoveLevelVisibilityTrackFromLevelSequence(FString LevelSequencePath, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a level visibility track in the level sequence
	UMovieSceneLevelVisibilityTrack* LevelVisibilityTrack = <a href="#GetLevelVisibilityTrackFromLevelSequence">GetLevelVisibilityTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelVisibilityTrack == nullptr) return;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return;

	// Remove track
	LevelSequence-&gt;MovieScene-&gt;RemoveTrack(*LevelVisibilityTrack);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Level Visibility Track From Level Sequence Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Link a level sequence to a level visibility track in a level sequence</mark>
 *
 * @param LevelSequencePath	The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param LevelName	The name of the level affected by the section
 * @param LevelVisibility	If true, the level will be set to visible
 * @param StartFrame	Start frame of the level visibility section in the level sequence
 * @param EndFrame	End frame of the level visibility section in the level sequence
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=sZX98hpPIp8" target="_blank">Level Visibility Track In Level Sequence</a>")
<strong>static void AddSectionToLevelVisibilityTrack(FString LevelSequencePath, FString LevelName, bool LevelVisibility, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieSceneLevelVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneLevelVisibilitySection.h" // MovieSceneTracks

void UExampleClass::AddSectionToLevelVisibilityTrack(FString LevelSequencePath, FString LevelName, bool LevelVisibility, int StartFrame, int EndFrame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a level visibility track in the level sequence
	UMovieSceneLevelVisibilityTrack* LevelVisibilityTrack = <a href="#GetLevelVisibilityTrackFromLevelSequence">GetLevelVisibilityTrackFromLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelVisibilityTrack == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Section To Level Visibility Track Failed - Level visibility track isn't valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Create section
	UMovieSceneLevelVisibilitySection* Section = Cast&lt;UMovieSceneLevelVisibilitySection&gt;(LevelVisibilityTrack-&gt;CreateNewSection());
	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Section To Level Visibility Track Failed - Failed to create section. '%s'"), *LevelSequencePath);
		return;
	}

	// Set affected level and desired visibility
	Section-&gt;SetLevelNames(TArray&lt;FName&gt;({ *LevelName }));
	Section-&gt;SetVisibility(LevelVisibility ? ELevelVisibility::Visible : ELevelVisibility::Hidden);
	
	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast<ULevelSequence&gt;(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence->MovieScene-&gt;GetDisplayRate().AsDecimal();

	// Set frame range of the section
	Section-&gt;SetRange(TRange&lt;FFrameNumber&gt;(FFrameNumber(StartFrame * TicksPerFrame), FFrameNumber(EndFrame * TicksPerFrame)));

	// Place the section on a new row so it doesn't fight against another section
	int RowIndex = -1;
	for (UMovieSceneSection* ExistingSection : LevelVisibilityTrack-&gt;GetAllSections())
	{
		RowIndex = FMath::Max(RowIndex, ExistingSection-&gt;GetRowIndex());
	}
	Section-&gt;SetRowIndex(RowIndex + 1);

	// Add section to level visibility track
	LevelVisibilityTrack-&gt;AddSection(*Section);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Section To Level Visibility Track Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Get the transform track from an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 *
 * @return The transform track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static class UMovieScene3DTransformTrack* GetTransformTrackFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

UMovieScene3DTransformTrack* UExampleClass::GetTransformTrackFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return nullptr;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Get the transform track
	UMovieScene3DTransformTrack* TransformTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieScene3DTransformTrack&gt;(Guid);

	bOutSuccess = TransformTrack != nullptr;
	FString SucceededOrFailed = bOutSuccess ? "Succeeded" : "Failed";
	OutInfoMsg = FString::Printf(TEXT("Get Transform Track From Actor In Level Sequence %s - '%s'"), *SucceededOrFailed, *LevelSequencePath);

	<strong>return TransformTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Add a transform track to an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor		The actor in the level sequence
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The transform track
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static class UMovieScene3DTransformTrack* AddTransformTrackToActorInLevelSequence(FString LevelSequencePath, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

UMovieScene3DTransformTrack* UExampleClass::AddTransformTrackToActorInLevelSequence(FString LevelSequencePath, AActor* Actor,  bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a transform track in the level sequence
	UMovieScene3DTransformTrack* TransformTrack = <a href="#GetTransformTrackFromActorInLevelSequence">GetTransformTrackFromActorInLevelSequence</a>(LevelSequencePath, Actor, bOutSuccess, OutInfoMsg);
	if (TransformTrack != nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Transform Track In Level Sequence Failed - Track already in level sequence. '%s'"), *LevelSequencePath);
		<strong>return TransformTrack;</strong>
	}

	// Get actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return nullptr;
	
	// Load Level Sequence
	ULevelSequence* LevelSequence = UExampleClass::<a href="#loadlevelsequence">LoadLevelSequence</a>(LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (LevelSequence == nullptr) return nullptr;

	// Add track
	TransformTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieScene3DTransformTrack&gt;(Guid);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Transform Track In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	<strong>return TransformTrack;</strong>
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a transform track from an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor		The actor in the level sequence
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static void RemoveTransformTrackFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

void UExampleClass::RemoveTransformTrackFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a transform track in the level sequence
	UMovieScene3DTransformTrack* TransformTrack = <a href="#GetTransformTrackFromActorInLevelSequence">GetTransformTrackFromActorInLevelSequence</a>(LevelSequencePath, Actor, bOutSuccess, OutInfoMsg);
	if (TransformTrack == nullptr) return;
	
	// Load level sequence
	ULevelSequence* LevelSequence = Cast&lt;ULevelSequence&gt;(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));

	// Remove track
	LevelSequence-&gt;MovieScene-&gt;RemoveTrack(*TransformTrack);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Transform Track From Actor In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Get the transform section from an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor		The actor in the level sequence
 * @param SectionIndex	Index of the section
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The transform section
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static class UMovieScene3DTransformSection* GetTransformSectionFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int SectionIndex, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

UMovieScene3DTransformSection* UExampleClass::GetTransformSectionFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int SectionIndex, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a transform track in the level sequence
	UMovieScene3DTransformTrack* TransformTrack = <a href="#GetTransformTrackFromActorInLevelSequence">GetTransformTrackFromActorInLevelSequence</a>(LevelSequencePath, Actor, bOutSuccess, OutInfoMsg);
	if (TransformTrack == nullptr) return nullptr;
	
	// Get all sections
	TArray&lt;UMovieSceneSection*&gt; AllSections = TransformTrack-&gt;GetAllSections();

	// Make sure index is valid
	if (SectionIndex &lt; 0 || SectionIndex &gt;= AllSections.Num())
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Get Transform Section From Actor In Level Sequence Failed - Section index is invalid. '%s'"), *LevelSequencePath);
		return nullptr;
	}

	// Return section
	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Get Transform Section From Actor In Level Sequence Succeeded - '%s'"), *LevelSequencePath);

	return Cast&lt;UMovieScene3DTransformSection&gt;(AllSections[SectionIndex]);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Evaluation/Blending/MovieSceneBlendType.h" // MovieScene
/**
 * <mark>Add a transform section to an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor		The actor in the level sequence
 * @param StartFrame	Start frame of the section
 * @param EndFrame	End frame of the section
 * @param BlendType	Blend type of the section
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 *
 * @return The transform section
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static class UMovieScene3DTransformSection* AddTransformSectionToActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int StartFrame, int EndFrame, EMovieSceneBlendType BlendType, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

UMovieScene3DTransformSection* UExampleClass::AddTransformSectionToActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int StartFrame, int EndFrame, EMovieSceneBlendType BlendType, bool& bOutSuccess, FString& OutInfoMsg) {
	// Check if there's a transform track in the level sequence
	UMovieScene3DTransformTrack* TransformTrack = <a href="#GetTransformTrackFromActorInLevelSequence">GetTransformTrackFromActorInLevelSequence</a>(LevelSequencePath, Actor, bOutSuccess, OutInfoMsg);
	if (TransformTrack == nullptr) return nullptr;
	
	// Create section
	UMovieScene3DTransformSection* TransformSection = Cast&lt;UMovieScene3DTransformSection&gt;(TransformTrack-&gt;CreateNewSection());
	if (TransformSection == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Transform Section To Actor In Level Sequence Failed - Failed to create section. '%s'"), *LevelSequencePath);
		return nullptr;
	}

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast&lt;ULevelSequence&gt;(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();

	// Set frame range of the section
	TransformSection-&gt;SetRange(TRange&lt;FFrameNumber&gt;(FFrameNumber(StartFrame * TicksPerFrame), FFrameNumber(EndFrame * TicksPerFrame)));

	// Set blend type
	TransformSection-&gt;SetBlendType(BlendType);

	// Place the section on a new row so it doesn't fight against another section
	int RowIndex = -1;
	for (UMovieSceneSection* ExistingSection : TransformTrack-&gt;GetAllSections())
	{
		RowIndex = FMath::Max(RowIndex, ExistingSection-&gt;GetRowIndex());
	}
	TransformSection-&gt;SetRowIndex(RowIndex + 1);
	
	// Add section to track
	TransformTrack-&gt;AddSection(*TransformSection);

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Transform Section To Actor In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
	return TransformSection;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a transform section from an actor in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor		The actor in the level sequence
 * @param SectionIndex	Index of the section
 * @param bOutSuccess	If the action was a success or not
 * @param OutInfoMsg	More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=3CaYk5OyWVo" target="_blank">Transform Track In Level Sequence</a>")
<strong>static void RemoveTransformSectionFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int SectionIndex, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "Tracks/MovieScene3DTransformTrack.h" // MovieSceneTracks
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks

void UExampleClass::RemoveTransformSectionFromActorInLevelSequence(FString LevelSequencePath, AActor* Actor, int SectionIndex, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Check if there's a transform track in the level sequence
	UMovieScene3DTransformSection* TransformSection = <a href="#GetTransformSectionFromActorInLevelSequence">GetTransformSectionFromActorInLevelSequence</a>(LevelSequencePath, Actor, SectionIndex, bOutSuccess, OutInfoMsg);
	if (TransformSection == nullptr) return;
	
	// Get track
	UMovieScene3DTransformTrack* TransformTrack = <a href="#GetTransformTrackFromActorInLevelSequence">GetTransformTrackFromActorInLevelSequence</a>(LevelSequencePath, Actor, bOutSuccess, OutInfoMsg);

	// Remove section
	TransformTrack-&gt;RemoveSection(*TransformSection);

	// Refresh level sequence
	TransformTrack-&gt;Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Transform Section From Actor In Level Sequence Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Add a keyframe to a transform section in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param SectionIndex			Index of the section
 * @param Frame					Frame number
 * @param Transform				Value to apply to the keys
 * @param KeyInterpolation		Interpolation of the keys: 0=Cubic, 1=Linear, 2=Constant
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=bGyvVrySP00" target="_blank">Alex Quevillon - Add Transform Keyframe In Level Sequence</a>")
<strong>static void AddTransformKeyframe(FString LevelSequencePath, AActor* Actor, int SectionIndex, int Frame, FTransform Transform, int KeyInterpolation, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneDoubleChannel.h" // MovieScene

void UExampleClass::AddTransformKeyframe(FString LevelSequencePath, AActor* Actor, int SectionIndex, int Frame, FTransform Transform, int KeyInterpolation, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get the section
	UMovieScene3DTransformSection* Section = UExampleClass::<a href="#GetTransformSectionFromActorInLevelSequence">GetTransformSectionFromActorInLevelSequence</a>(LevelSequencePath, Actor, SectionIndex, bOutSuccess, OutInfoMsg);

	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Transform Keyframe Failed - Transform section is not valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Remove previous keyframe if there's one
	RemoveTransformKeyframe(LevelSequencePath, Actor, SectionIndex, Frame, bOutSuccess, OutInfoMsg);

	// Location
	AddKeyframeToDoubleChannel(Section, 0, Frame, Transform.GetLocation().X, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 1, Frame, Transform.GetLocation().Y, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 2, Frame, Transform.GetLocation().Z, KeyInterpolation, bOutSuccess, OutInfoMsg);
	// Rotation	
	AddKeyframeToDoubleChannel(Section, 3, Frame, Transform.Rotator().Roll, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 4, Frame, Transform.Rotator().Pitch, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 5, Frame, Transform.Rotator().Yaw, KeyInterpolation, bOutSuccess, OutInfoMsg);
	// Scale
	AddKeyframeToDoubleChannel(Section, 6, Frame, Transform.GetScale3D().X, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 7, Frame, Transform.GetScale3D().Y, KeyInterpolation, bOutSuccess, OutInfoMsg);
	AddKeyframeToDoubleChannel(Section, 8, Frame, Transform.GetScale3D().Z, KeyInterpolation, bOutSuccess, OutInfoMsg);

	OutInfoMsg = bOutSuccess ? FString::Printf(TEXT("Add Transform Keyframe Succeeded - '%s'"), *LevelSequencePath) : OutInfoMsg;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a keyframe from a transform section in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param SectionIndex			Index of the section
 * @param Frame					Frame number
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=bGyvVrySP00" target="_blank">Alex Quevillon - Add Transform Keyframe In Level Sequence</a>")
<strong>static void RemoveTransformKeyframe(FString LevelSequencePath, AActor* Actor, int SectionIndex, int Frame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneDoubleChannel.h" // MovieScene

void UExampleClass::RemoveTransformKeyframe(FString LevelSequencePath, AActor* Actor, int SectionIndex, int Frame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get the section
	UMovieScene3DTransformSection* Section = UExampleClass::<a href="#GetTransformSectionFromActorInLevelSequence">GetTransformSectionFromActorInLevelSequence</a>(LevelSequencePath, Actor, SectionIndex, bOutSuccess, OutInfoMsg);
	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Transform Keyframe Failed - Transform section is not valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Location
	RemoveKeyframeFromDoubleChannel(Section, 0, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 1, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 2, Frame, bOutSuccess, OutInfoMsg);
	// Rotation	
	RemoveKeyframeFromDoubleChannel(Section, 3, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 4, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 5, Frame, bOutSuccess, OutInfoMsg);
	// Scale
	RemoveKeyframeFromDoubleChannel(Section, 6, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 7, Frame, bOutSuccess, OutInfoMsg);
	RemoveKeyframeFromDoubleChannel(Section, 8, Frame, bOutSuccess, OutInfoMsg);

	OutInfoMsg = bOutSuccess ? FString::Printf(TEXT("Remove Transform Keyframe Succeeded - '%s'"), *LevelSequencePath) : OutInfoMsg;
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Add a keyframe to a double channel in a level sequence</mark>
 *
 * @param Section				Section to modify
 * @param ChannelIndex			Index of the channel
 * @param Frame					Frame number
 * @param Value					Value to apply to the keyframe
 * @param KeyInterpolation		Interpolation of the keys: 0=Cubic, 1=Linear, 2=Constant
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=bGyvVrySP00" target="_blank">Alex Quevillon - Add Transform Keyframe In Level Sequence</a>")
<strong>static void AddKeyframeToDoubleChannel(UMovieSceneSection* Section, int ChannelIndex, int Frame, double Value, int KeyInterpolation, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneDoubleChannel.h" // MovieScene

void UExampleClass::AddKeyframeToDoubleChannel(UMovieSceneSection* Section, int ChannelIndex, int Frame, double Value, int KeyInterpolation, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Make sure section is valid
	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Keyframe To Double Channel Failed - Section is not valid."));
		return;
	}

	// Get the channel
	FMovieSceneDoubleChannel* Channel = Section->GetChannelProxy().GetChannel<FMovieSceneDoubleChannel>(ChannelIndex);
	if (Channel == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Keyframe To Double Channel Failed - Channel is not valid."));
		return;
	}

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast<ULevelSequence>(Section->GetOutermostObject());;
	int TicksPerFrame = LevelSequence->MovieScene->GetTickResolution().AsDecimal() / LevelSequence->MovieScene->GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Add key to channel
	if (KeyInterpolation == 0)
	{
		Channel->AddCubicKey(FrameNumber, Value);
	}
	else if (KeyInterpolation == 1)
	{
		Channel->AddLinearKey(FrameNumber, Value);
	}
	else
	{
		Channel->AddConstantKey(FrameNumber, Value);
	}

	// Refresh section
	Section->Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Keyframe To Double Channel Succeeded"));
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

/**
 * <mark>Remove a keyframe from a double channel in a level sequence</mark>
 *
 * @param Section				Section to modify
 * @param ChannelIndex			Index of the channel
 * @param Frame					Frame number
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "Alex Quevillon - Add Transform Keyframe In Level Sequence")
<strong>static void RemoveKeyframeFromDoubleChannel(UMovieSceneSection* Section, int ChannelIndex, int Frame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneDoubleChannel.h" // MovieScene

void UExampleClass::RemoveKeyframeFromDoubleChannel(UMovieSceneSection* Section, int ChannelIndex, int Frame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Make sure section is valid
	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Keyframe From Double Channel Failed - Section is not valid."));
		return;
	}

	// Get the channel
	FMovieSceneDoubleChannel* Channel = Section->GetChannelProxy().GetChannel<FMovieSceneDoubleChannel>(ChannelIndex);
	if (Channel == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Keyframe From Double Channel Failed - Channel is not valid."));
		return;
	}

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast<ULevelSequence>(Section->GetOutermostObject());;
	int TicksPerFrame = LevelSequence->MovieScene->GetTickResolution().AsDecimal() / LevelSequence->MovieScene->GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Find key we want to remove
	TArray<FFrameNumber> UnusedKeyTimes;
	TArray<FKeyHandle> KeyHandles;
	Channel->GetKeys(TRange<FFrameNumber>(FrameNumber, FrameNumber), &UnusedKeyTimes, &KeyHandles);

	// Remove key
	Channel->DeleteKeys(KeyHandles);

	// Refresh section
	Section->Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Keyframe From Double Channel Succeeded"));
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // New Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Curves/RealCurve.h" // Engine
/**
 * <mark>Modify a keyframe interpolation in a transform section in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param SectionIndex			Index of the section in the transform track
 * @param ChannelIndex			Index of the channel in the section
 * @param Frame					Frame number
 * @param Value					Value to apply to the key
 * @param InterpMode			Interpolation of the key: 0=Cubic, 1=Linear, 2=Constant
 * @param TangentMode			Tangents of the key: 0=Auto, 1=User, 2=Break
 * @param ArriveTangent			Arrive tangent of the key
 * @param LeaveTangent			Leave tangent of the key
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg			More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=kFMR3KzUDgE" target="_blank">Alex Quevillon - Set Keyframe Interpolation In Level Sequence</a>")
<strong>static void SetKeyframeInterpolationInTransformTrack(FString LevelSequencePath, AActor* Actor, int SectionIndex, int ChannelIndex, int Frame, double Value, ERichCurveInterpMode InterpMode, ERichCurveTangentMode TangentMode, float ArriveTangent, float LeaveTangent, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Sections/MovieScene3DTransformSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneDoubleChannel.h" // MovieScene

void UExampleClass::SetKeyframeInterpolationInTransformTrack(FString LevelSequencePath, AActor* Actor, int SectionIndex, int ChannelIndex, int Frame, double Value, ERichCurveInterpMode InterpMode, ERichCurveTangentMode TangentMode, float ArriveTangent, float LeaveTangent, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get the section
	UMovieScene3DTransformSection* Section = UExampleClass::<a href="#GetTransformSectionFromActorInLevelSequence">GetTransformSectionFromActorInLevelSequence</a>(LevelSequencePath, Actor, SectionIndex, bOutSuccess, OutInfoMsg);
	if (Section == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Set Keyframe Interpolation In Double Channel Failed - Transform section is not valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Get the channel
	FMovieSceneDoubleChannel* Channel = Section-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneDoubleChannel&gt;(ChannelIndex);
	if (Channel == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Set Keyframe Interpolation In Double Channel Failed - Channel is not valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast&lt;ULevelSequence&gt;(Section-&gt;GetOutermostObject());;
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Find key(s) we want to modify
	TArray&lt;FFrameNumber&gt; UnusedKeyTimes;
	TArray&lt;FKeyHandle&gt; KeyHandles;
	Channel-&gt;GetKeys(TRange&lt;FFrameNumber&gt;(FrameNumber, FrameNumber), &UnusedKeyTimes, &KeyHandles);

	for (FKeyHandle Handle : KeyHandles)
	{
		// Find index
		int Index = Channel-&gt;GetData().GetIndex(Handle);
		// Apply settings
		Channel-&gt;GetData().GetValues()[Index].Value = Value;
		Channel-&gt;GetData().GetValues()[Index].InterpMode = InterpMode;
		Channel-&gt;GetData().GetValues()[Index].TangentMode = TangentMode;

		if (TangentMode == ERichCurveTangentMode::RCTM_Auto)
		{
			// When auto, should keep the tangents to 0 so Unreal controls them
			Channel-&gt;GetData().GetValues()[Index].Tangent.ArriveTangent = 0.0f;
			Channel-&gt;GetData().GetValues()[Index].Tangent.LeaveTangent = 0.0f;
		}
		else if (TangentMode == ERichCurveTangentMode::RCTM_User)
		{
			// When User, both tangents should be the same, in this case, we're using the ArriveTangent only
			Channel-&gt;GetData().GetValues()[Index].Tangent.ArriveTangent = ArriveTangent;
			Channel-&gt;GetData().GetValues()[Index].Tangent.LeaveTangent = ArriveTangent;
		}
		else if (TangentMode == ERichCurveTangentMode::RCTM_Break)
		{
			// When Brek, we can do anything we want
			Channel-&gt;GetData().GetValues()[Index].Tangent.ArriveTangent = ArriveTangent;
			Channel-&gt;GetData().GetValues()[Index].Tangent.LeaveTangent = LeaveTangent;
		}
	}

	// Refresh section
	Section-&gt;Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Set Keyframe Interpolation In Double Channel Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Kismet/BlueprintFunctionLibrary.h" // Engine
/**
 * <mark>Add a keyframe to a Visibility track in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param Frame					Frame number
 * @param Visibility			Value to apply to the key
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=RIfkPfqdwhQ" target="_blank">Alex Quevillon - Visibility Keyframe In Level Sequence</a>")
<strong>static void AddVisibilityKeyframe(FString LevelSequencePath, AActor* Actor, int Frame, bool Visibility, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Tracks/MovieSceneVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneBoolSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneBoolChannel.h" // MovieScene

void UExampleClass::AddVisibilityKeyframe(FString LevelSequencePath, AActor* Actor, int Frame, bool Visibility, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Remove previous keyframe if there's one
	RemoveVisibilityKeyframe(LevelSequencePath, Actor, Frame, bOutSuccess, OutInfoMsg);

	// Get actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	
	if (!Guid.IsValid()) return;
	
	// Load level sequence & calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast&lt;ULevelSequence&gt;(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Get the visibility track
	UMovieSceneVisibilityTrack* VisibilityTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneVisibilityTrack&gt;(Guid); 
	// Or create it if it doesn't exist
	if (VisibilityTrack == nullptr) VisibilityTrack = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneVisibilityTrack&gt;(Guid);
	
	// Get the visibility section. Or create it if it doesn't exist
	bool bSectionAdded = false;
	UMovieSceneBoolSection* BoolSection = Cast&lt;UMovieSceneBoolSection&gt;(VisibilityTrack-&gt;FindOrAddSection(FrameNumber, bSectionAdded));
	if (bSectionAdded) BoolSection-&gt;SetRange(TRange&lt;FFrameNumber&gt;::All());
	
	// Get the channel
	FMovieSceneBoolChannel* Channel = BoolSection-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneBoolChannel&gt;(0);

	// Add keyframe
	Channel-&gt;AddKeys({ FrameNumber }, { Visibility });

	// Refresh level sequence
	VisibilityTrack-&gt;Modify();
	BoolSection-&gt;Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Visibility Keyframe Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Kismet/BlueprintFunctionLibrary.h" // Engine
/**
 * <mark>Remove a keyframe from a Visibility track in a level sequence</mark>
 *
 * @param LevelSequencePath		The path of the level sequence asset: "/Game/Folder/MyLevelSequence"
 * @param Actor					The actor in the level sequence
 * @param Frame					Frame number
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg		More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=RIfkPfqdwhQ" target="_blank">Alex Quevillon - Visibility Keyframe In Level Sequence</a>")
<strong>static void RemoveVisibilityKeyframe(FString LevelSequencePath, AActor* Actor, int Frame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Tracks/MovieSceneVisibilityTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneBoolSection.h" // MovieSceneTracks
#include "Channels/MovieSceneChannelProxy.h" // MovieScene
#include "Channels/MovieSceneBoolChannel.h" // MovieScene

void UExampleClass::RemoveVisibilityKeyframe(FString LevelSequencePath, AActor* Actor, int Frame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Get actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequencePath, bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return;
	
	// Load level sequence & calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	ULevelSequence* LevelSequence = Cast&lt;ULevelSequence&gt;(StaticLoadObject(ULevelSequence::StaticClass(), nullptr, *LevelSequencePath));
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Get the visibility track
	UMovieSceneVisibilityTrack* VisibilityTrack = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneVisibilityTrack&gt;(Guid);
	if (VisibilityTrack == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Visibility Keyframe Failed - Visibility track is not valid. '%s'"), *LevelSequencePath);
		return;	
	}

	// Get the visibility section.
	UMovieSceneBoolSection* BoolSection = Cast&lt;UMovieSceneBoolSection&gt;(VisibilityTrack-&gt;FindSection(FrameNumber));
	if (BoolSection == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Remove Visibility Keyframe Failed - Visibility section is not valid. '%s'"), *LevelSequencePath);
		return;
	}

	// Get the channel
	FMovieSceneBoolChannel* Channel = BoolSection-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneBoolChannel&gt;(0);

	// Find key we want to remove
	TArray&lt;FFrameNumber&gt; UnusedKeyTimes;
	TArray&lt;FKeyHandle&gt; KeyHandles;
	Channel-&gt;GetKeys(TRange&lt;FFrameNumber&gt;(FrameNumber, FrameNumber), &UnusedKeyTimes, &KeyHandles);

	// Remove key
	Channel-&gt;DeleteKeys(KeyHandles);

	// Refresh section
	VisibilityTrack-&gt;Modify();
	BoolSection-&gt;Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Remove Visibility Keyframe Succeeded - '%s'"), *LevelSequencePath);
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject",
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Kismet/BlueprintFunctionLibrary.h" // Engine
/**
	 * <mark>Add a keyframe to a Mpc float or color section in a level sequence</mark>
	 *
	 * @param LevelSequence		The level sequence asset
	 * @param Frame				Frame number
	 * @param Collection		Material parameter collection asset
	 * @param Parameter			Name of the material parameter
	 * @param FloatValue		Value to apply to the float parameter
	 * @param ColorValue		Value to apply to the color parameter
	 * @param bColor			If true, apply ColorValue, else apply FloatValue
	 * @param bOutSuccess		If the action was a success or not
	 * @param OutInfoMsg		More information about the action's result
	 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=mk2mExL8sP4" target="_blank">Alex Quevillon -  Add Material Parameter Collection Keyframe In Level Sequence</a>")
<strong>static void AddMpcKeyframe(class ULevelSequence* LevelSequence, class UMaterialParameterCollection* Collection, int Frame, FString Parameter, float FloatValue, FLinearColor ColorValue, bool bColor, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene
#include "Tracks/MovieSceneMaterialParameterCollectionTrack.h" // MovieSceneTracks
#include "Materials/MaterialParameterCollection.h" // Engine

void UExampleClass::AddMpcKeyframe(ULevelSequence* LevelSequence, UMaterialParameterCollection* Collection, int Frame, FString Parameter, float FloatValue, FLinearColor ColorValue, bool bColor, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Validate Level Sequence
	if (LevelSequence == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Mpc Float Keyframe Failed - Level Sequence is not valid"));
		return;
	}

	// Validate MPC
	if (Collection == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add Mpc Float Keyframe Failed - Material Parameter Collection is not valid"));
		return;
	}

	// Get the Mpc track
	TArray<UMovieSceneTrack*> Tracks = LevelSequence->MovieScene->GetTracks();
	UMovieSceneMaterialParameterCollectionTrack* MpcTrack = nullptr;
	for (UMovieSceneTrack* Track : Tracks)
	{
		UMovieSceneMaterialParameterCollectionTrack* MpcT = Cast<UMovieSceneMaterialParameterCollectionTrack>(Track);
		if (MpcT != nullptr && MpcT->MPC == Collection)
		{ 
			MpcTrack = MpcT;
			break;
		}
	}

	// Or create it if it doesn't exist
	if (MpcTrack == nullptr)
	{
		MpcTrack = LevelSequence->MovieScene->AddTrack<UMovieSceneMaterialParameterCollectionTrack>();
		MpcTrack->MPC = Collection;
		MpcTrack->SetDisplayName(FText::FromString(Collection->GetName()));
	}
	
	// Get section or create if if it doesn't exist
	UMovieSceneSection* MpcSection = nullptr;
	if (MpcTrack->GetAllSections().Num() > 0)
	{
		MpcSection = MpcTrack->GetAllSections()[0];
	}
	else
	{
		MpcSection = MpcTrack->CreateNewSection();
		MpcSection->SetRange(TRange<FFrameNumber>::All());
		MpcTrack->AddSection(*MpcSection);
	}

	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int TicksPerFrame = LevelSequence->MovieScene->GetTickResolution().AsDecimal() / LevelSequence->MovieScene->GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	if (bColor)
	{
		// Add Color Keyframe
		MpcTrack->AddColorParameterKey(*Parameter, FrameNumber, ColorValue);
	}
	else
	{
		// Add Scalar Keyframe
		MpcTrack->AddScalarParameterKey(*Parameter, FrameNumber, FloatValue);
	}

	// Refresh level sequence
	MpcTrack->Modify();
	MpcSection->Modify();

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add Mpc Keyframe Succeeded"));
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Kismet/BlueprintFunctionLibrary.h" // Engine
/**
 * <mark>Add a keyframe to a few BP actor variables in a level sequence</mark>
 *
 * @param LevelSequence			The level sequence asset
 * @param Actor					The actor in the level sequence
 * @param Frame					Frame number
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg			More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=60MnwoznEJs" target="_blank">Alex Quevillon -  Add Material Parameter Collection Keyframe In Level Sequence</a>")
<strong>static void AddBpVariableKeyframe(class ULevelSequence* LevelSequence, AActor* Actor, int Frame, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequence.h" // LevelSequence
#include "MovieScene.h" // MovieScene
#include "MovieSceneSection.h" // MovieScene

#include "Tracks/MovieSceneBoolTrack.h" // MovieSceneTracks
#include "Sections/MovieSceneBoolSection.h" // MovieSceneTracks
#include "Channels/MovieSceneBoolChannel.h" // MovieScene

#include "Tracks/MovieSceneFloatTrack.h "// MovieSceneTracks
#include "Sections/MovieSceneFloatSection.h" // MovieSceneTracks
#include "Channels/MovieSceneFloatChannel.h" // MovieScene

#include "Tracks/MovieSceneByteTrack.h "// MovieSceneTracks
#include "Sections/MovieSceneByteSection.h" // MovieSceneTracks
#include "Channels/MovieSceneByteChannel.h" // MovieScene

void UExampleClass::AddBpVariableKeyframe(ULevelSequence* LevelSequence, AActor* Actor, int Frame, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Validate Level Sequence
	if (LevelSequence == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Add BP Variable Keyframe Failed - Level Sequence is not valid"));
		return;
	}
 
	// Get actor Guid
	FGuid Guid = UExampleClass::<a href="#GetActorGuidFromLevelSequence">GetActorGuidFromLevelSequence</a>(Actor, LevelSequence-&gt;GetPathName(), bOutSuccess, OutInfoMsg);
	if (!Guid.IsValid()) return;
	
	// Calculate the amount of Ticks Per Frame for the input frame numbers. 
	// Level Sequence works in ticks, not in frames and quantity of ticks varies based on TickResolution and DisplayRate.
	int TicksPerFrame = LevelSequence-&gt;MovieScene-&gt;GetTickResolution().AsDecimal() / LevelSequence-&gt;MovieScene-&gt;GetDisplayRate().AsDecimal();
	FFrameNumber FrameNumber = FFrameNumber(Frame * TicksPerFrame);

	// Bool variable
	{
		// Get variable track 
		UMovieSceneBoolTrack* Track = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneBoolTrack&gt;(Guid, <mark>"MyBpBoolVariableName"</mark>);
		// Or create it if it doesn't exist
		if (Track == nullptr)
		{
			Track = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneBoolTrack&gt;(Guid);
			Track-&gt;SetPropertyNameAndPath("MyBpBoolVariableName", "MyBpBoolVariableName");
			// To find the PropertyName & PropertyPath, add a breakpoint in UMovieScenePropertyTrack::SetPropertyNameAndPath and add the track manually in editor
		}

		// Get the section or create it if it doesn't exist
		bool bSectionAdded = false;
		UMovieSceneBoolSection* Section = Cast&lt;UMovieSceneBoolSection&gt;(Track-&gt;FindOrAddSection(FrameNumber, bSectionAdded));
		if (bSectionAdded) Section-&gt;SetRange(TRange&lt;FFrameNumber&gt;::All());
		
		// Get the channel
		FMovieSceneBoolChannel* Channel = Section-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneBoolChannel>(0);

		// Add keyframe
		Channel-&gt;AddKeys({ FrameNumber }, { FMath::RandBool() });

		// Refresh level sequence
		Track-&gt;Modify();
		Section-&gt;Modify();
	}
	// Float variable
	{
		// Get variable track 
		UMovieSceneFloatTrack* Track = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneFloatTrack>(Guid, <mark>"MyBpFloatVariableName"</mark>);
		// Or create it if it doesn't exist
		if (Track == nullptr)
		{
			Track = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneFloatTrack&gt;(Guid);
			Track-&gt;SetPropertyNameAndPath("MyBpFloatVariableName", "MyBpFloatVariableName");
		}

		// Get the section or create it if it doesn't exist
		bool bSectionAdded = false;
		UMovieSceneFloatSection* Section = Cast&lt;UMovieSceneFloatSection&gt;(Track-&gt;FindOrAddSection(FrameNumber, bSectionAdded));
		if (bSectionAdded) Section-&gt;SetRange(TRange&lt;FFrameNumber&gt;::All());
		
		// Get the channel
		FMovieSceneFloatChannel* Channel = Section-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneFloatChannel&gt;(0);

		// Add keyframe
		Channel-&gt;AddLinearKey(FrameNumber, FMath::RandRange(-100.0f, 100.0f));

		// Refresh level sequence
		Track-&gt;Modify();
		Section-&gt;Modify();
	}
	// Byte variable
	{
		// Get variable track 
		UMovieSceneByteTrack* Track = LevelSequence-&gt;MovieScene-&gt;FindTrack&lt;UMovieSceneByteTrack&gt;(Guid, <mark>"MyBpByteVariableName"</mark>);
		// Or create it if it doesn't exist
		if (Track == nullptr)
		{
			Track = LevelSequence-&gt;MovieScene-&gt;AddTrack&lt;UMovieSceneByteTrack&gt;(Guid);
			Track-&gt;SetPropertyNameAndPath("MyBpByteVariableName", "MyBpByteVariableName");
		}

		// Get the section or create it if it doesn't exist
		bool bSectionAdded = false;
		UMovieSceneByteSection* Section = Cast&lt;UMovieSceneByteSection&gt;(Track-&gt;FindOrAddSection(FrameNumber, bSectionAdded));
		if (bSectionAdded) Section-&gt;SetRange(TRange&lt;FFrameNumber&gt;::All());
		
		// Get the channel
		FMovieSceneByteChannel* Channel = Section-&gt;GetChannelProxy().GetChannel&lt;FMovieSceneByteChannel&gt;(0);

		// Add keyframe
		Channel-&gt;AddKeys({ FrameNumber }, { uint8(FMath::RandRange(0, 7)) });

		// Refresh level sequence
		Track-&gt;Modify();
		Section-&gt;Modify();
	}

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Add BP Variable Keyframe Succeeded"));
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"MovieScene"</mark>,
    <mark>MovieSceneTracks</mark>,
  }
);

#include "Kismet/BlueprintFunctionLibrary.h" // Engine
/**
 * <mark>Start a render process</mark>
 *
 * @param LevelSequence			The level sequence asset to render
 * @param OutputDirectory		Where to save the output: "C:/Temp/MyRenderFolder"
 * @param bRenderAsMovie		If true, will render a movie. Otherwise, will render individual frames
 * @param bOutSuccess			If the action was a success or not
 * @param OutInfoMsg			More information about the action's result
 */
UFUNCTION(BlueprintCallable, Category = "<a href="https://www.youtube.com/watch?v=mTKZosgBXAk" target="_blank">Alex Quevillon -  Start the Render of a Level Sequence</a>")
<strong>static void StartLevelSequenceRender(class ULevelSequence* LevelSequence, FString OutputDirectory, bool bRenderAsMovie, bool& bOutSuccess, FString& OutInfoMsg);</strong>

#include "LevelSequenceActor.h" // LevelSequence
#include "SequencerTools.h" // SequencerScriptingEditor
#include "AutomatedLevelSequenceCapture.h" // MovieSceneTools
#include "Protocols/ImageSequenceProtocol.h" // MovieSceneCapture
#include "Protocols/VideoCaptureProtocol.h" // MovieSceneCapture & AVIWriter
#include "Protocols/AudioCaptureProtocol.h" // MovieSceneCapture

void UExampleClass::StartLevelSequenceRender(ULevelSequence* LevelSequence, FString OutputDirectory, bool bRenderAsMovie, bool& bOutSuccess, FString& OutInfoMsg)
{
	// Validate Level Sequence
	if (LevelSequence == nullptr)
	{
		bOutSuccess = false;
		OutInfoMsg = FString::Printf(TEXT("Start Level Sequence Render Failed - Level Sequence is not valid"));
		return;
	}

	// Create Capture Settings (Same as Render Movie Settings window)
	UAutomatedLevelSequenceCapture* Capture = NewObject<UAutomatedLevelSequenceCapture>();
	
	// Level sequence
	Capture->LevelSequenceAsset = LevelSequence;

	// Output directory
	FDirectoryPath DirPath;
	DirPath.Path = OutputDirectory;
	Capture->Settings.OutputDirectory = DirPath;

	// Render type
	if (bRenderAsMovie)
	{
		Capture->SetImageCaptureProtocolType(UVideoCaptureProtocol::StaticClass());
		Cast<UVideoCaptureProtocol>(Capture->ImageCaptureProtocol)->bUseCompression = true;
		Cast<UVideoCaptureProtocol>(Capture->ImageCaptureProtocol)->CompressionQuality = 75;

		// Possible Classes: UNullAudioCaptureProtocol, UMasterAudioSubmixCaptureProtocol
		Capture->SetAudioCaptureProtocolType(UNullAudioCaptureProtocol::StaticClass());
	}
	else
	{
		// Possible Classes: UImageSequenceProtocol_JPG, UImageSequenceProtocol_PNG, UImageSequenceProtocol_BMP, UImageSequenceProtocol_EXR
		Capture->SetImageCaptureProtocolType(UImageSequenceProtocol_PNG::StaticClass());
		Cast<UImageSequenceProtocol_PNG>(Capture->ImageCaptureProtocol)->CompressionQuality = 75;
	}


	// UMovieSceneCapture
	Capture->bUseSeparateProcess = true; // If true, set bCloseEditorWhenCaptureStarts, AdditionalCommandLineArguments & InheritedCommandLineArguments.
	Capture->bCloseEditorWhenCaptureStarts = false;
	Capture->AdditionalCommandLineArguments = "-NOSCREENMESSAGES";
	Capture->InheritedCommandLineArguments = "-skipcompile";

	// FMovieSceneCaptureSettings
	Capture->Settings.GameModeOverride = nullptr;
	Capture->Settings.OutputFormat = "{shot}_{frame}";
	Capture->Settings.bOverwriteExisting = true;
	Capture->Settings.bUseRelativeFrameNumbers = false;
	Capture->Settings.HandleFrames = 0;
	Capture->Settings.ZeroPadFrameNumbers = 0;
	Capture->Settings.FrameRate = FFrameRate(30, 1);
	Capture->Settings.bUseCustomFrameRate = false; // If true, set CustomFrameRate
	Capture->Settings.Resolution = FCaptureResolution(1920, 1080);
	Capture->Settings.bEnableTextureStreaming = false;
	Capture->Settings.bCinematicEngineScalability = false;
	Capture->Settings.bCinematicMode = false; // If true, set bAllowMovement, bAllowTurning, bShowPlayer, bShowHUD
	Capture->Settings.bUsePathTracer = false; // If true, set PathTracerSamplePerPixel

	// UAutomatedLevelSequenceCapture
	Capture->ShotName = "MyRender";
	Capture->bUseCustomStartFrame = false; // If true, set CustomStartFrame
	Capture->bUseCustomEndFrame = false; // If true, set CustomEndFrame
	Capture->WarmUpFrameCount = 0;
	Capture->DelayBeforeWarmUp = 0.0f;
	Capture->DelayBeforeShotWarmUp = 0.0f;
	Capture->DelayEveryFrame = 0.0f;
	Capture->bWriteEditDecisionList = false;
	Capture->bWriteFinalCutProXML = false;

	// ULevelSequenceBurnInOptions
	ULevelSequenceBurnInOptions* BurnIn = NewObject<ULevelSequenceBurnInOptions>();
	BurnIn->bUseBurnIn = true;
	Capture->BurnInOptions = BurnIn;

	// Start Render
	USequencerToolsFunctionLibrary::RenderMovie(Capture, FOnRenderMovieStopped());

	bOutSuccess = true;
	OutInfoMsg = FString::Printf(TEXT("Start Level Sequence Render Succeeded"));
}

PrivateDependencyModuleNames.AddRange
(
  new string[] 
  { 
    // Default Modules
    "Core", 
    "CoreUObject", 
    "Engine", 

    // Required Modules
    <mark>"LevelSequence"</mark>,
    <mark>"SequencerScriptingEditor"</mark>,
    <mark>"MovieSceneTools"</mark>,
	<mark>"MovieSceneCapture"</mark>,
	<mark>"AVIWriter"</mark>,
  }
);