CameraShakeBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/EnumClassFlags.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "UObject/ScriptMacros.h"
#include "Camera/CameraTypes.h"
#include "Engine/Scene.h"
 
#include "CameraShakeBase.generated.h"
 
class APlayerCameraManager;
class UCameraShakePattern;
 
USTRUCT(BlueprintType)
struct FCameraShakePatternStartParams
{
    GENERATED_BODY()
    
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    bool bIsRestarting = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    bool bOverrideDuration = false;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake, meta=(EditCondition="bOverrideDuration"))
    float DurationOverride = 0.f;
};
 
USTRUCT(BlueprintType)
struct FCameraShakePatternUpdateParams
{
    GENERATED_BODY()
 
    FCameraShakePatternUpdateParams()
    {}
 
    FCameraShakePatternUpdateParams(const FMinimalViewInfo& InPOV)
        : POV(InPOV)
    {}
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float DeltaTime = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float ShakeScale = 1.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float DynamicScale = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    FMinimalViewInfo POV;
 
    float GetTotalScale() const
    {
        return FMath::Max(ShakeScale * DynamicScale, 0.f);
    }
};
 
USTRUCT(BlueprintType)
struct FCameraShakePatternScrubParams
{
    GENERATED_BODY()
 
    FCameraShakePatternScrubParams()
    {}
 
    FCameraShakePatternScrubParams(const FMinimalViewInfo& InPOV)
        : POV(InPOV)
    {}
 
    ENGINE_API FCameraShakePatternUpdateParams ToUpdateParams() const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float AbsoluteTime = 0.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float ShakeScale = 1.f;
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    float DynamicScale = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    FMinimalViewInfo POV;
 
    float GetTotalScale() const
    {
        return FMath::Max(ShakeScale * DynamicScale, 0.f);
    }
};
 
UENUM()
enum class ECameraShakePatternUpdateResultFlags : uint8
{
    ApplyAsAbsolute = 1 << 0,
    SkipAutoScale = 1 << 1,
    SkipAutoPlaySpace = 1 << 2,
 
    Default = 0
};
ENUM_CLASS_FLAGS(ECameraShakePatternUpdateResultFlags);
 
USTRUCT(BlueprintType)
struct FCameraShakePatternUpdateResult
{
    GENERATED_BODY()
 
    FCameraShakePatternUpdateResult()
        : Location(FVector::ZeroVector)
        , Rotation(FRotator::ZeroRotator)
        , FOV(0.f)
        , PostProcessBlendWeight(0.f)
        , Flags(ECameraShakePatternUpdateResultFlags::Default)
    {}
 
    FVector Location;
    FRotator Rotation;
    float FOV;
 
    FPostProcessSettings PostProcessSettings;
    float PostProcessBlendWeight;
 
    ECameraShakePatternUpdateResultFlags Flags;
 
    ENGINE_API void ApplyScale(float InScale);
};
 
USTRUCT(BlueprintType)
struct FCameraShakePatternStopParams
{
    GENERATED_BODY()
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=CameraShake)
    bool bImmediately = false;
};
 
// Redirections from old names.
#if !defined(UE_LEGACY_CAMERA_SHAKE_PATTERN_TYPES)
#define UE_LEGACY_CAMERA_SHAKE_PATTERN_TYPES 0
#endif
 
#if UE_LEGACY_CAMERA_SHAKE_PATTERN_TYPES
using ECameraShakeUpdateResultFlags = ECameraShakePatternUpdateResultFlags;
using FCameraShakeStartParams = FCameraShakePatternStartParams;
using FCameraShakeUpdateParams = FCameraShakePatternUpdateParams;
using FCameraShakeScrubParams = FCameraShakePatternScrubParams;
using FCameraShakeStopParams = FCameraShakePatternStopParams;
using FCameraShakeUpdateResult = FCameraShakePatternUpdateResult;
#endif // UE_LEGACY_CAMERA_SHAKE_PATTERN_TYPES
 
UENUM()
enum class ECameraShakeDurationType : uint8
{
    Fixed,
    Infinite,
    Custom
};
 
USTRUCT(BlueprintType)
struct FCameraShakeDuration
{
    GENERATED_BODY()
 
    
    static FCameraShakeDuration Infinite() { return FCameraShakeDuration { 0.f, ECameraShakeDurationType::Infinite }; }
    static FCameraShakeDuration Custom() { return FCameraShakeDuration { 0.f, ECameraShakeDurationType::Custom }; }
    static FCameraShakeDuration Custom(float DurationHint) { return FCameraShakeDuration{ DurationHint, ECameraShakeDurationType::Custom }; }
 
    FCameraShakeDuration() : Duration(0.f), Type(ECameraShakeDurationType::Fixed) {}
    FCameraShakeDuration(float InDuration, ECameraShakeDurationType InType = ECameraShakeDurationType::Fixed) : Duration(InDuration), Type(InType) {}
    
    ECameraShakeDurationType GetDurationType() const { return Type; }
    bool IsFixed() const { return Type == ECameraShakeDurationType::Fixed; }
    bool IsInfinite() const { return Type == ECameraShakeDurationType::Infinite; }
    bool IsCustom() const { return Type == ECameraShakeDurationType::Custom; }
    bool IsCustomWithHint() const { return IsCustom() && Duration > 0.f; }
 
    float Get() const { check(Type == ECameraShakeDurationType::Fixed || Type == ECameraShakeDurationType::Custom); return Duration; }
 
private:
    UPROPERTY()
    float Duration;
 
    UPROPERTY()
    ECameraShakeDurationType Type;
};
 
USTRUCT(BlueprintType)
struct FCameraShakeInfo
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    FCameraShakeDuration Duration;
 
    UPROPERTY()
    float BlendIn = 0.f;
 
    UPROPERTY()
    float BlendOut = 0.f;
};
 
struct FCameraShakeApplyResultParams
{
    float Scale = 1.f;
    ECameraShakePlaySpace PlaySpace = ECameraShakePlaySpace::CameraLocal;
    FMatrix UserPlaySpaceMatrix;
 
    TWeakObjectPtr<APlayerCameraManager> CameraManager;
};
 
struct FCameraShakeState
{
    ENGINE_API FCameraShakeState();
 
    ENGINE_API void Start(const FCameraShakeInfo& InShakeInfo);
 
    ENGINE_API void Start(const FCameraShakeInfo& InShakeInfo, TOptional<float> InDurationOverride);
 
    ENGINE_API void Start(const UCameraShakePattern* InShakePattern);
    
    ENGINE_API void Start(const UCameraShakePattern* InShakePattern, const FCameraShakePatternStartParams& InParams);
 
    ENGINE_API float Update(float DeltaTime);
 
    ENGINE_API float Scrub(float AbsoluteTime);
 
    ENGINE_API void Stop(bool bImmediately);
 
    bool IsPlaying() const { return bIsPlaying; }
 
    bool IsBlendingIn() const { return bIsBlendingIn; }
 
    bool IsBlendingOut() const { return bIsBlendingOut; }
 
    float GetElapsedTime() const { return ElapsedTime; }
 
    float GetCurrentBlendInTime() const { return CurrentBlendInTime; }
 
    float GetCurrentBlendOutTime() const { return CurrentBlendOutTime; }
 
    const FCameraShakeInfo& GetShakeInfo() const { return ShakeInfo; }
 
    bool HasDuration() const { return ShakeInfo.Duration.IsFixed(); }
 
    float GetDuration() const { return ShakeInfo.Duration.Get(); }
 
    bool IsInfinite() const { return ShakeInfo.Duration.IsInfinite(); }
 
private:
 
    ENGINE_API void InitializePlaying();
 
private:
 
    // Information about the shake/shake pattern we're managing
    FCameraShakeInfo ShakeInfo;
 
    // Running state
    float ElapsedTime;
 
    float CurrentBlendInTime;
    float CurrentBlendOutTime;
 
    bool bIsBlendingIn : 1;
    bool bIsBlendingOut : 1;
 
    bool bIsPlaying : 1;
 
    // Cached values for blending information
    bool bHasBlendIn : 1;
    bool bHasBlendOut : 1;
};
 
struct FCameraShakeBaseStartParams
{
    TObjectPtr<APlayerCameraManager> CameraManager;
 
    float Scale = 1.f;
 
    ECameraShakePlaySpace PlaySpace = ECameraShakePlaySpace::CameraLocal;
 
    FRotator UserPlaySpaceRot = FRotator::ZeroRotator;
 
    TOptional<float> DurationOverride;
};
 
UCLASS(Abstract, Blueprintable, EditInlineNew, MinimalAPI)
class UCameraShakeBase : public UObject
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API UCameraShakeBase(const FObjectInitializer& ObjectInitializer);
    
public:
 
    ENGINE_API FCameraShakeDuration GetCameraShakeDuration() const;
 
    ENGINE_API void GetCameraShakeBlendTimes(float& OutBlendIn, float& OutBlendOut) const;
 
    static bool GetCameraShakeDuration(TSubclassOf<UCameraShakeBase> CameraShakeClass, FCameraShakeDuration& OutDuration)
    {
        if (CameraShakeClass)
        {
            if (const UCameraShakeBase* CDO = CameraShakeClass->GetDefaultObject<UCameraShakeBase>())
            {
                OutDuration = CDO->GetCameraShakeDuration();
                return true;
            }
        }
        return false;
    }
 
    static bool GetCameraShakeBlendTimes(TSubclassOf<UCameraShakeBase> CameraShakeClass, float& OutBlendIn, float& OutBlendOut)
    {
        if (CameraShakeClass)
        {
            if (const UCameraShakeBase* CDO = CameraShakeClass->GetDefaultObject<UCameraShakeBase>())
            {
                CDO->GetCameraShakeBlendTimes(OutBlendIn, OutBlendOut);
                return true;
            }
        }
        return false;
    }
 
    static ENGINE_API void ApplyResult(const FCameraShakeApplyResultParams& ApplyParams, const FCameraShakePatternUpdateResult& InResult, FMinimalViewInfo& InOutPOV);
 
    static ENGINE_API void ApplyScale(const FCameraShakePatternUpdateParams& Params, FCameraShakePatternUpdateResult& InOutResult);
 
    static ENGINE_API void ApplyScale(float Scale, FCameraShakePatternUpdateResult& InOutResult);
 
    static ENGINE_API void ApplyLimits(const FMinimalViewInfo& InPOV, FCameraShakePatternUpdateResult& InOutResult);
 
    static ENGINE_API void ApplyPlaySpace(ECameraShakePlaySpace PlaySpace, FMatrix UserPlaySpaceMatrix, const FMinimalViewInfo& InPOV, FCameraShakePatternUpdateResult& InOutResult);
 
public:
 
    UPROPERTY(EditAnywhere, Category=CameraShake)
    bool bSingleInstance;
 
    UPROPERTY(transient, BlueprintReadWrite, Category=CameraShake)
    float ShakeScale;
 
    UFUNCTION(BlueprintPure, Category="CameraShake")
    UCameraShakePattern* GetRootShakePattern() const { return RootShakePattern; }
 
    UFUNCTION(BlueprintCallable, Category="CameraShake")
    ENGINE_API void SetRootShakePattern(UCameraShakePattern* InPattern);
 
    template<typename ShakePatternType>
    ShakePatternType* ChangeRootShakePattern()
    {
        ShakePatternType* ShakePattern = NewObject<ShakePatternType>(this);
        SetRootShakePattern(ShakePattern);
        return ShakePattern;
    }
 
public:
 
    ENGINE_API void GetShakeInfo(FCameraShakeInfo& OutInfo) const;
 
    bool IsActive() const { return bIsActive; }
 
    ENGINE_API void StartShake(APlayerCameraManager* Camera, float Scale, ECameraShakePlaySpace InPlaySpace, FRotator UserPlaySpaceRot = FRotator::ZeroRotator);
 
    ENGINE_API void StartShake(const FCameraShakeBaseStartParams& Params);
 
    ENGINE_API bool IsFinished() const;
 
    ENGINE_API void UpdateAndApplyCameraShake(float DeltaTime, float Alpha, FMinimalViewInfo& InOutPOV);
 
    ENGINE_API void ScrubAndApplyCameraShake(float AbsoluteTime, float Alpha, FMinimalViewInfo& InOutPOV);
 
    ENGINE_API void StopShake(bool bImmediately = true);
 
    ENGINE_API void TeardownShake();
 
public:
 
    APlayerCameraManager* GetCameraManager() const { return CameraManager; }
 
    ECameraShakePlaySpace GetPlaySpace() const { return PlaySpace; }
    const FMatrix& GetUserPlaySpaceMatrix() const { return UserPlaySpaceMatrix; }
    void SetUserPlaySpaceMatrix(const FMatrix& InMatrix) { UserPlaySpaceMatrix = InMatrix; }
 
protected:
 
    ENGINE_API void ApplyPlaySpace(const FCameraShakePatternUpdateParams& Params, FCameraShakePatternUpdateResult& InOutResult) const;
 
private:
 
    UPROPERTY(EditAnywhere, Instanced, Category=CameraShakePattern)
    TObjectPtr<UCameraShakePattern> RootShakePattern;
 
    UPROPERTY(transient)
    TObjectPtr<APlayerCameraManager> CameraManager;
 
    ECameraShakePlaySpace PlaySpace;
 
    FMatrix UserPlaySpaceMatrix;
 
    bool bIsActive;
};
 
UCLASS(Abstract, EditInlineNew, MinimalAPI)
class UCameraShakePattern : public UObject
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API UCameraShakePattern(const FObjectInitializer& ObjectInitializer);
 
    ENGINE_API void GetShakePatternInfo(FCameraShakeInfo& OutInfo) const;
    ENGINE_API void StartShakePattern(const FCameraShakePatternStartParams& Params);
    ENGINE_API void UpdateShakePattern(const FCameraShakePatternUpdateParams& Params, FCameraShakePatternUpdateResult& OutResult);
    ENGINE_API void ScrubShakePattern(const FCameraShakePatternScrubParams& Params, FCameraShakePatternUpdateResult& OutResult);
    ENGINE_API bool IsFinished() const;
    ENGINE_API void StopShakePattern(const FCameraShakePatternStopParams& Params);
    ENGINE_API void TeardownShakePattern();
 
protected:
 
    ENGINE_API UCameraShakeBase* GetShakeInstance() const;
 
    template<typename InstanceType>
    InstanceType* GetShakeInstance() const { return Cast<InstanceType>(GetShakeInstance()); }
 
private:
 
    // UCameraShakePattern interface
    virtual void GetShakePatternInfoImpl(FCameraShakeInfo& OutInfo) const {}
    virtual void StartShakePatternImpl(const FCameraShakePatternStartParams& Params) {}
    virtual void UpdateShakePatternImpl(const FCameraShakePatternUpdateParams& Params, FCameraShakePatternUpdateResult& OutResult) {}
    virtual void ScrubShakePatternImpl(const FCameraShakePatternScrubParams& Params, FCameraShakePatternUpdateResult& OutResult) {}
    virtual bool IsFinishedImpl() const { return true; }
    virtual void StopShakePatternImpl(const FCameraShakePatternStopParams& Params) {}
    virtual void TeardownShakePatternImpl()  {}
};