CineCameraSettings.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/DeveloperSettings.h"
#include "Engine/Scene.h"
#include "Templates/SharedPointer.h"
#include "CineCameraSettings.generated.h"
 
class SNotificationItem;
 
USTRUCT(BlueprintType)
struct FCameraFilmbackSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Filmback", meta = (ClampMin = "0.001", ForceUnits = mm))
    float SensorWidth;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Filmback", meta = (ClampMin = "0.001", ForceUnits = mm))
    float SensorHeight;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Filmback", meta = (ForceUnits = mm))
    float SensorHorizontalOffset;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Filmback", meta = (ForceUnits = mm))
    float SensorVerticalOffset;
    
    UPROPERTY(Interp, VisibleAnywhere, BlueprintReadOnly, Category = "Filmback")
    float SensorAspectRatio;
 
    bool operator==(const FCameraFilmbackSettings& Other) const
    {
        return (SensorWidth == Other.SensorWidth)
            && (SensorHeight == Other.SensorHeight)
            && (SensorHorizontalOffset == Other.SensorHorizontalOffset)
            && (SensorVerticalOffset == Other.SensorVerticalOffset);
    }
 
    bool operator!=(const FCameraFilmbackSettings& Other) const
    {
        return !operator==(Other);
    }
 
    void RecalcSensorAspectRatio()
    {
        SensorAspectRatio = (SensorHeight > 0.f) ? (SensorWidth / SensorHeight) : 0.f;
    }
 
    FCameraFilmbackSettings()
        : SensorWidth(24.89f)
        , SensorHeight(18.67f)
        , SensorHorizontalOffset(0.0f)
        , SensorVerticalOffset(0.0f)
        , SensorAspectRatio(1.33f)
    {
    }
};
 
USTRUCT(BlueprintType)
struct FNamedFilmbackPreset
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Filmback")
    FString Name;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Filmback")
    FText DisplayName;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Filmback")
    FCameraFilmbackSettings FilmbackSettings;
};
 
USTRUCT(BlueprintType)
struct FCameraLensSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    FCameraLensSettings()
        : MinFocalLength(50.f)
        , MaxFocalLength(50.f)
        , MinFStop(2.f)
        , MaxFStop(2.f)
        , MinimumFocusDistance(15.f)
        , DiaphragmBladeCount(FPostProcessSettings::kDefaultDepthOfFieldBladeCount)
    {
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens", meta = (ForceUnits = mm, ClampMin = "0.001"))
    float MinFocalLength = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens", meta = (ForceUnits = mm, ClampMin = "0.001"))
    float MaxFocalLength = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens")
    float MinFStop = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens")
    float MaxFStop = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens", meta = (ForceUnits = mm))
    float MinimumFocusDistance = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens", meta = (ClampMin = "1", ClampMax = "2"))
    float SqueezeFactor = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Lens", meta = (ClampMin = "4", ClampMax = "16"))
    int32 DiaphragmBladeCount = 0;
 
    bool operator==(const FCameraLensSettings& Other) const
    {
        return (MinFocalLength == Other.MinFocalLength)
            && (MaxFocalLength == Other.MaxFocalLength)
            && (MinFStop == Other.MinFStop)
            && (MaxFStop == Other.MaxFStop)
            && (MinimumFocusDistance == Other.MinimumFocusDistance)
            && (SqueezeFactor == Other.SqueezeFactor)
            && (DiaphragmBladeCount == Other.DiaphragmBladeCount);
    }
};
 
USTRUCT(BlueprintType)
struct FNamedLensPreset
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Lens")
    FString Name;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Lens")
    FCameraLensSettings LensSettings;
};
 
USTRUCT(BlueprintType)
struct FPlateCropSettings
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Crop", meta=(DisplayName = "Cropped Aspect Ratio"))
    float AspectRatio = 0.f;
 
    bool operator==(const FPlateCropSettings& Other) const
    {
        return (AspectRatio == Other.AspectRatio);
    }
};
 
USTRUCT(BlueprintType)
struct FNamedPlateCropPreset
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Crop")
    FString Name;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Crop")
    FPlateCropSettings CropSettings;
};
 
UENUM()
enum class ECameraFocusMethod : uint8
{
    DoNotOverride,
 
    Manual,
 
    Tracking,
 
    Disable,
 
    MAX UMETA(Hidden)
};
 
USTRUCT(BlueprintType)
struct FCameraTrackingFocusSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Tracking Focus")
    TSoftObjectPtr<AActor> ActorToTrack;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Tracking Focus")
    FVector RelativeOffset;
 
    UPROPERTY(Transient, EditAnywhere, BlueprintReadWrite, Category = "Tracking Focus")
    uint8 bDrawDebugTrackingFocusPoint : 1;
 
    FCameraTrackingFocusSettings()
        : RelativeOffset(ForceInitToZero),
        bDrawDebugTrackingFocusPoint(false)
    {}
};
 
USTRUCT(BlueprintType)
struct FCameraFocusSettings
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Focus Method")
    ECameraFocusMethod FocusMethod;
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Manual Focus Settings", meta=(Units=cm))
    float ManualFocusDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Tracking Focus Settings")
    FCameraTrackingFocusSettings TrackingFocusSettings;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient, EditAnywhere, Category = "Focus Settings")
    uint8 bDrawDebugFocusPlane : 1;
 
    UPROPERTY(EditAnywhere, Category = "Focus Settings", meta = (EditCondition = "bDrawDebugFocusPlane"))
    FColor DebugFocusPlaneColor;
#endif 
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Focus Settings")
    uint8 bSmoothFocusChanges : 1;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Focus Settings")
    float FocusSmoothingInterpSpeed;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = "Focus Settings")
    float FocusOffset;
 
    FCameraFocusSettings() : 
        FocusMethod(ECameraFocusMethod::Manual),
        ManualFocusDistance(100000.f),
        TrackingFocusSettings(),
#if WITH_EDITORONLY_DATA
        bDrawDebugFocusPlane(false),
        DebugFocusPlaneColor(102, 26, 204, 153),        // purple
#endif
        bSmoothFocusChanges(false),
        FocusSmoothingInterpSpeed(8.f),
        FocusOffset(0.f)
    {}
};
 
UENUM()
enum class ECameraExposureMethod : uint8
{
    DoNotOverride,
 
    Enabled,
 
    MAX UMETA(Hidden)
};
 
UCLASS(config=Engine, defaultconfig, meta=(DisplayName="Cinematic Camera"), MinimalAPI)
class UCineCameraSettings : public UDeveloperSettings
{
    GENERATED_BODY()
 
public:
    CINEMATICCAMERA_API virtual void PostInitProperties() override;
 
#if WITH_EDITOR
    CINEMATICCAMERA_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetDefaultLensPresetName, Category=Lens, meta=(GetOptions=GetLensPresetNames))
    FString DefaultLensPresetName;
    
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetDefaultLensFocalLength, Category=Lens)
    float DefaultLensFocalLength;
    
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetDefaultLensFStop, Category=Lens)
    float DefaultLensFStop;
    
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetLensPresets, Category=Lens, meta=(TitleProperty=Name))
    TArray<FNamedLensPreset> LensPresets;
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetDefaultfilmbackPreset, Category=Filmback, meta=(GetOptions=GetFilmbackPresetNames))
    FString DefaultFilmbackPreset;
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetFilmbackPresets, Category=Filmback, meta=(TitleProperty=Name))
    TArray<FNamedFilmbackPreset> FilmbackPresets;
 
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetDefaultCropPresetName, Category=Crop, meta=(GetOptions=GetCropPresetNames))
    FString DefaultCropPresetName;
    
    UPROPERTY(config, EditAnywhere, BlueprintReadWrite, BlueprintSetter=SetCropPresets, Category=Crop, meta=(TitleProperty=Name))
    TArray<FNamedPlateCropPreset> CropPresets;
 
    static CINEMATICCAMERA_API TArray<FNamedLensPreset> const& GetLensPresets();
    static CINEMATICCAMERA_API TArray<FNamedFilmbackPreset> const& GetFilmbackPresets();
    static CINEMATICCAMERA_API TArray<FNamedPlateCropPreset> const& GetCropPresets();
 
    // Gets the Lens settings associated with a given preset name
    // Returns true if a preset with the given name was found
    UFUNCTION(BlueprintCallable, Category=Cinematics, meta=(ReturnDisplayName = "Success"))
    CINEMATICCAMERA_API bool GetLensPresetByName(const FString PresetName, FCameraLensSettings& LensSettings);
 
    // Gets the Filmback settings associated with a given preset name
    // Returns true if a preset with the given name was found
    UFUNCTION(BlueprintCallable, Category=Cinematics, meta=(ReturnDisplayName = "Success"))
    CINEMATICCAMERA_API bool GetFilmbackPresetByName(const FString PresetName, FCameraFilmbackSettings& FilmbackSettings);
 
    // Gets the Crop settings associated with a given preset name
    // Returns true if a preset with the given name was found
    UFUNCTION(BlueprintCallable, Category=Cinematics, meta=(ReturnDisplayName = "Success"))
    CINEMATICCAMERA_API bool GetCropPresetByName(const FString PresetName, FPlateCropSettings& CropSettings);
 
private:
    UFUNCTION(BlueprintCallable, Category=Cinematics)
    static UCineCameraSettings* GetCineCameraSettings();
 
    /* Internal Blueprint Setter functions that call SaveConfig after setting the variable to ensure settings persist */
    
    UFUNCTION(BlueprintSetter)
    void SetDefaultLensPresetName(const FString InDefaultLensPresetName);
 
    UFUNCTION(BlueprintSetter)
    void SetDefaultLensFocalLength(const float InDefaultLensFocalLength);
 
    UFUNCTION(BlueprintSetter)
    void SetDefaultLensFStop(const float InDefaultLensFStop);
 
    UFUNCTION(BlueprintSetter)
    void SetLensPresets(const TArray<FNamedLensPreset>& InLensPresets);
 
    UFUNCTION(BlueprintSetter)
    void SetDefaultFilmbackPreset(const FString InDefaultFilmbackPreset);
 
    UFUNCTION(BlueprintSetter)
    void SetFilmbackPresets(const TArray<FNamedFilmbackPreset>& InFilmbackPresets);
 
    UFUNCTION(BlueprintSetter)
    void SetDefaultCropPresetName(const FString InDefaultCropPresetName);
 
    UFUNCTION(BlueprintSetter)
    void SetCropPresets(const TArray<FNamedPlateCropPreset>& InCropPresets);
 
    /* Functions used for the GetOptions metadata */
    
    UFUNCTION()
    TArray<FString> GetLensPresetNames() const;
 
    UFUNCTION()
    TArray<FString> GetFilmbackPresetNames() const;
 
    UFUNCTION()
    TArray<FString> GetCropPresetNames() const;
 
    static const FString CineCameraConfigSection;
    TSharedPtr<SNotificationItem> Notification;
    void CopyOldConfigSettings();
    void CloseNotification();
 
    // Sensor aspect ratio is derived from Sensor Height and Width so needs to be updated when either property is updated
    void RecalcSensorAspectRatios();
};