LevelSequenceActor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/SoftObjectPath.h"
#include "GameFramework/Actor.h"
#include "IMovieScenePlaybackClient.h"
#include "MovieSceneSequencePlaybackSettings.h"
#include "MovieSceneBindingOwnerInterface.h"
#include "MovieSceneBindingOverrides.h"
#include "LevelSequenceCameraSettings.h"
#include "WorldPartition/IWorldPartitionObjectResolver.h"
 
#include "LevelSequenceActor.generated.h"
 
class ULevelSequenceBurnIn;
class ULevelSequencePlayer;
class UMovieSceneSequenceTickManager;
 
UCLASS(Blueprintable, DefaultToInstanced, MinimalAPI)
class ULevelSequenceBurnInInitSettings : public UObject
{
    GENERATED_BODY()
};
 
UCLASS(config=EditorPerProjectUserSettings, PerObjectConfig, DefaultToInstanced, BlueprintType, MinimalAPI)
class ULevelSequenceBurnInOptions : public UObject
{
public:
 
    GENERATED_BODY()
    LEVELSEQUENCE_API ULevelSequenceBurnInOptions(const FObjectInitializer& Init);
 
    UFUNCTION(BlueprintCallable, Category = "General")
    LEVELSEQUENCE_API void SetBurnIn(FSoftClassPath InBurnInClass);
 
    LEVELSEQUENCE_API void ResetSettings();
 
public:
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, Category="General")
    bool bUseBurnIn;
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, Category="General", meta=(EditCondition=bUseBurnIn, MetaClass="/Script/LevelSequence.LevelSequenceBurnIn"))
    FSoftClassPath BurnInClass;
 
    UPROPERTY(Instanced, EditAnywhere, BlueprintReadWrite, Category="General", meta=(EditCondition=bUseBurnIn))
    TObjectPtr<ULevelSequenceBurnInInitSettings> Settings;
 
protected:
 
#if WITH_EDITOR
    LEVELSEQUENCE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif //WITH_EDITOR
};
 
UCLASS(hideCategories=(Rendering, Physics, HLOD, Activation, Input), MinimalAPI)
class ALevelSequenceActor
    : public AActor
    , public IMovieScenePlaybackClient
    , public IMovieSceneBindingOwnerInterface
    , public IWorldPartitionObjectResolver
{
public:
 
    DECLARE_DYNAMIC_DELEGATE(FOnLevelSequenceLoaded);
 
    GENERATED_BODY()
 
    
    LEVELSEQUENCE_API ALevelSequenceActor(const FObjectInitializer& Init);
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Playback", meta=(ShowOnlyInnerProperties, ExposeOnSpawn))
    FMovieSceneSequencePlaybackSettings PlaybackSettings;
 
    UE_DEPRECATED(5.4, "Direct access to SequencePlayer will be removed. Please use GetSequencePlayer()")
    UPROPERTY(Instanced, transient, replicated, BlueprintReadOnly, BlueprintGetter = GetSequencePlayer, Category = "Playback", meta = (ExposeFunctionCategories = "Sequencer|Player"))
    TObjectPtr<ULevelSequencePlayer> SequencePlayer;
 
    UPROPERTY(EditAnywhere, replicated, BlueprintReadOnly, Category="General", meta=(AllowedClasses="/Script/LevelSequence.LevelSequence", ExposeOnSpawn))
    TObjectPtr<ULevelSequence> LevelSequenceAsset;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FSoftObjectPath LevelSequence_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Cameras", meta=(ShowOnlyInnerProperties, ExposeOnSpawn))
    FLevelSequenceCameraSettings CameraSettings;
 
    UPROPERTY(Instanced, BlueprintReadOnly, Category="General")
    TObjectPtr<ULevelSequenceBurnInOptions> BurnInOptions;
 
    UPROPERTY(Instanced, BlueprintReadOnly, Category="General")
    TObjectPtr<UMovieSceneBindingOverrides> BindingOverrides;
 
    UPROPERTY()
    uint8 bAutoPlay_DEPRECATED : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="General")
    uint8 bOverrideInstanceData : 1;
 
    UPROPERTY(EditAnywhere, DisplayName="Replicate Playback", BlueprintReadWrite, BlueprintSetter=SetReplicatePlayback, Category=Replication, meta=(ExposeOnSpawn))
    uint8 bReplicatePlayback:1;
 
    UPROPERTY(Instanced, BlueprintReadWrite, Category="General")
    TObjectPtr<UObject> DefaultInstanceData;
 
public:
 
    UFUNCTION(BlueprintCallable, Category="Sequencer|Player")
    LEVELSEQUENCE_API ULevelSequence* GetSequence() const;
 
    UFUNCTION(BlueprintCallable, Category="Sequencer|Player")
    LEVELSEQUENCE_API void SetSequence(ULevelSequence* InSequence);
 
    UFUNCTION(BlueprintSetter)
    LEVELSEQUENCE_API void SetReplicatePlayback(bool ReplicatePlayback);
 
    UFUNCTION(BlueprintGetter)
    LEVELSEQUENCE_API ULevelSequencePlayer* GetSequencePlayer() const;
 
    /* Hide burnin */
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    LEVELSEQUENCE_API void HideBurnin();
 
    /* Show burnin */
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player")
    LEVELSEQUENCE_API void ShowBurnin();
 
    LEVELSEQUENCE_API void RefreshBurnIn();
 
public:
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void SetBinding(FMovieSceneObjectBindingID Binding, const TArray<AActor*>& Actors, bool bAllowBindingsFromAsset = false);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void SetBindingByTag(FName BindingTag, const TArray<AActor*>& Actors, bool bAllowBindingsFromAsset = false);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void AddBinding(FMovieSceneObjectBindingID Binding, AActor* Actor, bool bAllowBindingsFromAsset = false);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void AddBindingByTag(FName BindingTag, AActor* Actor, bool bAllowBindingsFromAsset = false);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void RemoveBinding(FMovieSceneObjectBindingID Binding, AActor* Actor);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void RemoveBindingByTag(FName Tag, AActor* Actor);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void ResetBinding(FMovieSceneObjectBindingID Binding);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings")
    LEVELSEQUENCE_API void ResetBindings();
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings", DisplayName="Find Binding by Tag")
    LEVELSEQUENCE_API FMovieSceneObjectBindingID FindNamedBinding(FName Tag) const;
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Player|Bindings", DisplayName="Find Bindings by Tag")
    LEVELSEQUENCE_API const TArray<FMovieSceneObjectBindingID>& FindNamedBindings(FName Tag) const;
 
protected:
 
    //~ Begin IMovieScenePlaybackClient interface
    LEVELSEQUENCE_API virtual bool RetrieveBindingOverrides(const FGuid& InBindingId, FMovieSceneSequenceID InSequenceID, TArray<UObject*, TInlineAllocator<1>>& OutObjects) const override;
    LEVELSEQUENCE_API virtual UObject* GetInstanceData() const override;
    LEVELSEQUENCE_API virtual TOptional<EAspectRatioAxisConstraint> GetAspectRatioAxisConstraint() const override;
    LEVELSEQUENCE_API virtual bool GetIsReplicatedPlayback() const override;
    //~ End IMovieScenePlaybackClient interface
 
    //~ Begin UObject interface
    LEVELSEQUENCE_API virtual void PostInitProperties() override;
    LEVELSEQUENCE_API virtual void PostLoad() override;
public:
#if WITH_EDITORONLY_DATA
    static LEVELSEQUENCE_API void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
protected:
 
    //~ End UObject interface
 
    //~ Begin AActor interface
    LEVELSEQUENCE_API virtual void PreInitializeComponents() override;
    LEVELSEQUENCE_API virtual void PostInitializeComponents() override;
    LEVELSEQUENCE_API virtual void BeginPlay() override;
    LEVELSEQUENCE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    LEVELSEQUENCE_API virtual void RewindForReplay() override;
    LEVELSEQUENCE_API virtual void PostNetReceive() override;
#if WITH_EDITOR
    virtual bool CanChangeIsSpatiallyLoadedFlag() const override { return false; }
#endif
    //~ End AActor interface
 
public:
 
    const FWorldPartitionResolveData& GetWorldPartitionResolveData() const
    {
        return WorldPartitionResolveData;
    }
 
#if WITH_EDITOR
    virtual void SetWorldPartitionResolveData(const FWorldPartitionResolveData& InWorldPartitionResolveData)
    {
        WorldPartitionResolveData = InWorldPartitionResolveData;
    }
 
    LEVELSEQUENCE_API virtual bool GetReferencedContentObjects(TArray<UObject*>& Objects) const override;
#endif //WITH_EDITOR
 
    LEVELSEQUENCE_API void InitializePlayer();
 
    LEVELSEQUENCE_API void InitializePlayerWithSequence(ULevelSequence* LevelSequenceAsset);
    LEVELSEQUENCE_API void OnSequenceLoaded(const FName& PackageName, UPackage* Package, EAsyncLoadingResult::Type Result);
 
#if WITH_EDITOR
    LEVELSEQUENCE_API virtual TSharedPtr<FStructOnScope> GetObjectPickerProxy(TSharedPtr<IPropertyHandle> PropertyHandle) override;
    LEVELSEQUENCE_API virtual void UpdateObjectFromProxy(FStructOnScope& Proxy, IPropertyHandle& ObjectPropertyHandle) override;
    LEVELSEQUENCE_API virtual UMovieSceneSequence* RetrieveOwnedSequence() const override;
#endif
 
private:
    UPROPERTY()
    TObjectPtr<ULevelSequenceBurnIn> BurnInInstance;
 
    UPROPERTY()
    bool bShowBurnin;
 
    UPROPERTY()
    FWorldPartitionResolveData WorldPartitionResolveData;
};
 
USTRUCT()
struct FBoundActorProxy
{
    GENERATED_BODY()
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(EditInstanceOnly, AdvancedDisplay, Category="General")
    TObjectPtr<AActor> BoundActor = nullptr;
 
    LEVELSEQUENCE_API void Initialize(TSharedPtr<IPropertyHandle> InPropertyHandle);
 
    LEVELSEQUENCE_API void OnReflectedPropertyChanged();
 
    TSharedPtr<IPropertyHandle> ReflectedProperty;
 
#endif
};
 
UCLASS(MinimalAPI)
class AReplicatedLevelSequenceActor
    : public ALevelSequenceActor
{
    GENERATED_BODY()
 
public:
    LEVELSEQUENCE_API AReplicatedLevelSequenceActor(const FObjectInitializer& Init);
};