MovieSceneCaptureProtocolBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Interface.h"
#include "MovieSceneCaptureSettings.h"
#include "MovieSceneCaptureProtocolBase.generated.h"
 
class FSceneViewport;
 
struct FFrameRate;
struct FFrameMetrics;
struct ICaptureProtocolHost;
struct FMovieSceneCaptureSettings;
 
 
UENUM()
enum class EMovieSceneCaptureProtocolState : uint8
{
    Idle,
    Initialized,
    Capturing,
    Finalizing,
};
 
struct FCaptureProtocolInitSettings
{
    MOVIESCENECAPTURE_API static FCaptureProtocolInitSettings FromSlateViewport(TSharedRef<FSceneViewport> InSceneViewport);
    
    TSharedPtr<FSceneViewport> SceneViewport;
    FIntPoint DesiredSize;
 
private:
    FCaptureProtocolInitSettings() {}
};
 
 
UCLASS(config=EditorPerProjectUserSettings, PerObjectConfig, Abstract, MinimalAPI)
class UMovieSceneCaptureProtocolBase : public UObject
{
public:
 
    GENERATED_BODY()
 
    MOVIESCENECAPTURE_API UMovieSceneCaptureProtocolBase(const FObjectInitializer& ObjInit);
 
public:
 
    UFUNCTION(BlueprintCallable, Category=Capture)
    EMovieSceneCaptureProtocolState GetState() const { return State; }
 
    UFUNCTION(BlueprintCallable, Category=Capture)
    bool IsCapturing() const { return State == EMovieSceneCaptureProtocolState::Capturing || bFrameRequested[GFrameCounter%2] == true; }
 
    MOVIESCENECAPTURE_API bool Setup(const FCaptureProtocolInitSettings& InSettings, const ICaptureProtocolHost* Host);
 
    MOVIESCENECAPTURE_API virtual class UWorld* GetWorld() const override;
public:
 
    MOVIESCENECAPTURE_API void PreTick();
 
    MOVIESCENECAPTURE_API void Tick();
 
    MOVIESCENECAPTURE_API void WarmUp();
 
    MOVIESCENECAPTURE_API bool StartCapture();
 
    MOVIESCENECAPTURE_API void CaptureFrame(const FFrameMetrics& FrameMetrics);
 
    MOVIESCENECAPTURE_API void BeginFinalize();
 
    MOVIESCENECAPTURE_API bool HasFinishedProcessing() const;
 
    MOVIESCENECAPTURE_API void Finalize();
 
    MOVIESCENECAPTURE_API void AddFormatMappings(TMap<FString, FStringFormatArg>& FormatMappings) const;
 
    MOVIESCENECAPTURE_API void OnReleaseConfig(FMovieSceneCaptureSettings& InSettings);
 
    MOVIESCENECAPTURE_API void OnLoadConfig(FMovieSceneCaptureSettings& InSettings);
 
    MOVIESCENECAPTURE_API bool CanWriteToFile(const TCHAR* InFilename, bool bOverwriteExisting) const;
 
protected:
 
    virtual bool SetupImpl()
    {
        return true;
    }
 
    virtual void PreTickImpl() {}
 
    virtual void TickImpl() {}
 
    virtual void WarmUpImpl() {}
 
    virtual bool StartCaptureImpl()
    {
        return true;
    }
 
    virtual void CaptureFrameImpl(const FFrameMetrics& FrameMetrics) {}
 
    virtual void PauseCaptureImpl() {}
 
    virtual void BeginFinalizeImpl() {}
 
    virtual bool HasFinishedProcessingImpl() const { return true; }
 
    virtual void FinalizeImpl() {}
 
    virtual void AddFormatMappingsImpl(TMap<FString, FStringFormatArg>& FormatMappings) const {}
 
    virtual void OnReleaseConfigImpl(FMovieSceneCaptureSettings& InSettings) {}
 
    virtual void OnLoadConfigImpl(FMovieSceneCaptureSettings& InSettings) {}
 
    MOVIESCENECAPTURE_API virtual bool CanWriteToFileImpl(const TCHAR* InFilename, bool bOverwriteExisting) const;
    MOVIESCENECAPTURE_API virtual FString GenerateFilenameImpl(const FFrameMetrics& FrameMetrics, const TCHAR* Extension, const FString* NameFormatString = nullptr) const;
    MOVIESCENECAPTURE_API void EnsureFileWritableImpl(const FString& File) const;
 
protected:
 
    TOptional<FCaptureProtocolInitSettings> InitSettings;
 
    const ICaptureProtocolHost* CaptureHost;
 
private:
 
    UPROPERTY(transient)
    EMovieSceneCaptureProtocolState State;
 
    bool bFrameRequested[2];
};
 
UCLASS(config = EditorPerProjectUserSettings, PerObjectConfig, Abstract, MinimalAPI)
class  UMovieSceneImageCaptureProtocolBase : public UMovieSceneCaptureProtocolBase
{
    GENERATED_BODY()
 
public:
    UMovieSceneImageCaptureProtocolBase(const FObjectInitializer& ObjInit)
        : UMovieSceneCaptureProtocolBase(ObjInit)
    {}
 
};
 
UCLASS(config = EditorPerProjectUserSettings, PerObjectConfig, Abstract, MinimalAPI)
class UMovieSceneAudioCaptureProtocolBase : public UMovieSceneCaptureProtocolBase
{
    GENERATED_BODY()
 
public:
    UMovieSceneAudioCaptureProtocolBase(const FObjectInitializer& ObjInit)
        : UMovieSceneCaptureProtocolBase(ObjInit)
    {}
};
 
USTRUCT(BlueprintType)
struct FFrameMetrics
{
    GENERATED_BODY()
 
    
    FFrameMetrics() : TotalElapsedTime(0), FrameDelta(0), FrameNumber(0), NumDroppedFrames(0) {}
 
    FFrameMetrics(float InTotalElapsedTime, float InFrameDelta, int32 InFrameNumber, int32 InNumDroppedFrames)
        : TotalElapsedTime(InTotalElapsedTime), FrameDelta(InFrameDelta), FrameNumber(InFrameNumber), NumDroppedFrames(InNumDroppedFrames)
    {
    }
 
    UPROPERTY(BlueprintReadOnly, Category=Capture)
    float TotalElapsedTime;
 
    UPROPERTY(BlueprintReadOnly, Category=Capture)
    float FrameDelta;
 
    UPROPERTY(BlueprintReadOnly, Category=Capture)
    int32 FrameNumber;
 
    UPROPERTY(BlueprintReadOnly, Category=Capture)
    int32 NumDroppedFrames;
};
 
 
struct ICaptureStrategy
{
    virtual ~ICaptureStrategy(){}
 
    virtual void OnInitialize() = 0;
    virtual void OnStop() = 0;
    virtual bool ShouldSynchronizeFrames() const { return true; }
 
    virtual bool ShouldPresent(double CurrentTimeSeconds, uint32 FrameIndex) const = 0;
    virtual int32 GetDroppedFrames(double CurrentTimeSeconds, uint32 FrameIndex) const = 0;
};
 
 
struct ICaptureProtocolHost
{
    virtual const FMovieSceneCaptureSettings& GetSettings() const = 0;
 
    virtual const int32 GetFrameNumberOffset() const = 0;
 
    virtual FFrameRate GetCaptureFrameRate() const = 0;
 
    virtual const ICaptureStrategy& GetCaptureStrategy() const = 0;
 
    virtual FString ResolveFileFormat(const FString& Format, const FFrameMetrics& FrameMetrics) const = 0;
 
    virtual double GetEstimatedCaptureDurationSeconds() const = 0;
};