MoviePlayer.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 "Rendering/RenderingCommon.h"
#include "Rendering/SlateRenderer.h"
#include "Widgets/SWidget.h"
#include "Slate/SlateTextures.h"
 
#include "MoviePlayer.generated.h"
 
// In order for a platform to support early movie playback, the platform must support the rendering thread 
// starting very early and support rendering as soon as it is started and the module containing the movie streamer for the platform must already be loaded
 
UENUM()
enum EMoviePlaybackType : int
{
    MT_Normal UMETA(DisplayName="Normal Playback"),
    MT_Looped UMETA(DisplayName = "Looped Playback"),
    MT_LoadingLoop UMETA(DisplayName = "Looped Last Playback"),
    MT_MAX UMETA(Hidden)
};
 
class FMovieViewport : public ISlateViewport, public TSharedFromThis<FMovieViewport>
{
public:
    FMovieViewport() : DefaultSize(ForceInitToZero) {}
    ~FMovieViewport() {}
 
    /* ISlateViewport interface. */
    virtual FIntPoint GetSize() const override
    {
        TSharedPtr<FSlateTexture2DRHIRef, ESPMode::ThreadSafe> SlateTextureSharedPtr = SlateTexture.Pin();
        return SlateTextureSharedPtr.IsValid() ? FIntPoint(SlateTextureSharedPtr->GetWidth(), SlateTextureSharedPtr->GetHeight()) : DefaultSize;
    }
 
    virtual class FSlateShaderResource* GetViewportRenderTargetTexture() const override
    {
        return SlateTexture.IsValid() ? SlateTexture.Pin().Get() : NULL;
    }
 
    virtual bool RequiresVsync() const override
    {
        return false;
    }
 
    void SetTexture(TWeakPtr<FSlateTexture2DRHIRef, ESPMode::ThreadSafe> InTexture)
    {
        SlateTexture = InTexture;
    }
 
    void SetDefaultSize(FIntPoint InSize)
    {
        DefaultSize = InSize;
    }
 
private:
    TWeakPtr<FSlateTexture2DRHIRef, ESPMode::ThreadSafe> SlateTexture;
 
    FIntPoint DefaultSize;
};
 
 
class IMovieStreamer
{
public:
    virtual bool Init(const TArray<FString>& MoviePaths, TEnumAsByte<EMoviePlaybackType> inPlaybackType) = 0;
    
    virtual void PreviousViewportInterface(const TSharedPtr<ISlateViewport>& PreviousViewportInterface) {};
 
    virtual void ForceCompletion() = 0;
 
    virtual bool Tick(FRHICommandListBase& RHICmdList, float DeltaTime) = 0;
 
    virtual TSharedPtr<class ISlateViewport> GetViewportInterface() = 0;
 
    virtual float GetAspectRatio() const = 0;
 
    virtual FString GetMovieName() = 0;
 
    virtual bool IsLastMovieInPlaylist() = 0;
 
    virtual void Cleanup() = 0;
 
    virtual FTextureRHIRef GetTexture() { return nullptr; }
 
    virtual ~IMovieStreamer() {}
 
    DECLARE_EVENT_OneParam(IMovieStreamer, FOnCurrentMovieClipFinished, const FString&)
    virtual FOnCurrentMovieClipFinished& OnCurrentMovieClipFinished() = 0;
 
    void BroadcastCurrentMovieClipFinished(const FString& MovieClipThatFinished) { OnCurrentMovieClipFinished().Broadcast(MovieClipThatFinished); }
 
    virtual void Suspend() {};
    virtual void Resume() {};
 
    // MediaFramework support.
    virtual void TickPreEngine() {};
    virtual void TickPostEngine() {};
    virtual void TickPostRender() {};
};
 
 
 
struct FLoadingScreenAttributes
{
    FLoadingScreenAttributes()
        : MinimumLoadingScreenDisplayTime(-1.0f)
        , bAutoCompleteWhenLoadingCompletes(true)
        , bMoviesAreSkippable(true)
        , bWaitForManualStop(false)
        , bAllowInEarlyStartup(false)
        , bAllowEngineTick(false)
        , PlaybackType(EMoviePlaybackType::MT_Normal) {}
 
    TSharedPtr<class SWidget> WidgetLoadingScreen;
 
    TArray<FString> MoviePaths;
 
    float MinimumLoadingScreenDisplayTime;
 
    bool bAutoCompleteWhenLoadingCompletes;
 
    bool bMoviesAreSkippable;
 
    bool bWaitForManualStop;
 
    bool bAllowInEarlyStartup;
 
    bool bAllowEngineTick;
 
    TEnumAsByte<EMoviePlaybackType> PlaybackType;
 
    MOVIEPLAYER_API bool IsValid() const;
 
    static MOVIEPLAYER_API TSharedRef<class SWidget> NewTestLoadingScreenWidget();
};
 
 
class IGameMoviePlayer
{
public:
    virtual void RegisterMovieStreamer(TSharedPtr<IMovieStreamer, ESPMode::ThreadSafe> InMovieStreamer) = 0;
 
    virtual void Initialize(class FSlateRenderer& InSlateRenderer, TSharedPtr<SWindow> RenderTarget = nullptr) = 0;
 
    virtual void Shutdown() = 0;
 
    virtual void PassLoadingScreenWindowBackToGame() const = 0;
    
    virtual void SetupLoadingScreen(const FLoadingScreenAttributes& InLoadingScreenAttributes) = 0;
    
    DECLARE_EVENT(IGameMoviePlayer, FOnPrepareLoadingScreen)
    virtual FOnPrepareLoadingScreen& OnPrepareLoadingScreen() = 0;
 
    virtual bool HasEarlyStartupMovie() const = 0;
 
    virtual bool PlayEarlyStartupMovies() = 0;
 
    virtual bool IsInitialized() const = 0;
 
    virtual bool PlayMovie() = 0;
 
    virtual void StopMovie() = 0;
    
    virtual void WaitForMovieToFinish(bool bAllowEngineTick = false) = 0;
 
    virtual bool IsLoadingFinished() const = 0;
 
    virtual bool IsMovieCurrentlyPlaying() const = 0;
 
    virtual bool LoadingScreenIsPrepared() const = 0;
    
    virtual void SetupLoadingScreenFromIni() = 0;
 
    virtual FString GetMovieName() = 0;
 
    virtual bool IsLastMovieInPlaylist() = 0;
 
    /* Callback for when the LoadingScreen setup above in WidgetLoadingScreen is displayed **/
    DECLARE_EVENT(IGameMoviePlayer, FOnMoviePlaybackStarted)
    virtual FOnMoviePlaybackStarted& OnMoviePlaybackStarted() = 0;
 
    DECLARE_EVENT_OneParam(IGameMoviePlayer, FOnMoviePlaybackTick, float DeltaTime)
    virtual FOnMoviePlaybackTick& OnMoviePlaybackTick() = 0;
 
    DECLARE_EVENT(IGameMoviePlayer, FOnMoviePlaybackFinished)
    virtual FOnMoviePlaybackFinished& OnMoviePlaybackFinished() = 0;
 
    DECLARE_EVENT_OneParam(IGameMoviePlayer, FOnMovieClipFinished, const FString&)
    virtual FOnMovieClipFinished& OnMovieClipFinished() = 0;
 
    virtual void SetSlateOverlayWidget(TSharedPtr<SWidget> NewOverlayWidget) = 0;
    virtual void SetViewportDPIScale(float InViewportDPIScale) {}
 
    void BroadcastMoviePlaybackFinished() { OnMoviePlaybackFinished().Broadcast(); }
    void BroadcastMovieClipFinished(const FString& MovieClipThatFinished) { OnMovieClipFinished().Broadcast(MovieClipThatFinished); }
 
    virtual bool WillAutoCompleteWhenLoadFinishes() = 0;
 
    virtual ~IGameMoviePlayer() {}
 
    virtual bool IsStartupMoviePlaying() const { return false; };
    virtual void ForceCompletion() {};
    virtual void Suspend() {};
    virtual void Resume() {};
 
    virtual void SetIsPlayOnBlockingEnabled(bool bIsEnabled) {}
};
 
MOVIEPLAYER_API void CreateMoviePlayer();
 
MOVIEPLAYER_API void DestroyMoviePlayer();
 
MOVIEPLAYER_API IGameMoviePlayer* GetMoviePlayer();
 
MOVIEPLAYER_API IGameMoviePlayer& GetMoviePlayerRef();
 
bool MOVIEPLAYER_API IsMoviePlayerEnabled();