PlayerCameraManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "Templates/SubclassOf.h"
#include "Engine/EngineTypes.h"
#include "GameFramework/Actor.h"
#include "Camera/CameraTypes.h"
#include "UObject/ScriptInterface.h"
#include "PlayerCameraManager.generated.h"
 
class AEmitterCameraLensEffectBase;
class APlayerController;
class FDebugDisplayInfo;
class UCameraModifier;
class UCameraShakeBase;
class UCameraShakeSourceComponent;
class ICameraLensEffectInterface;
struct FAddCameraShakeParams;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnAudioFadeChangeSignature, bool, bFadeOut, float, FadeTime);
 
UENUM()
enum EViewTargetBlendFunction : int
{
    VTBlend_Linear,
    VTBlend_Cubic,
    VTBlend_EaseIn,
    VTBlend_EaseOut,
    VTBlend_EaseInOut,
    VTBlend_PreBlended,
    VTBlend_MAX,
};
 
UENUM()
enum EViewTargetBlendOrder : int
{
    VTBlendOrder_Base,
    VTBlendOrder_Override
};
 
USTRUCT()
struct FCameraCacheEntry
{
    GENERATED_USTRUCT_BODY()
public:
 
    UPROPERTY()
    float TimeStamp;
 
    UPROPERTY()
    FMinimalViewInfo POV;
 
    FCameraCacheEntry()
        : TimeStamp(0.f)
    {}
};
 
USTRUCT(BlueprintType)
struct FTViewTarget
{
    GENERATED_USTRUCT_BODY()
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TViewTarget)
    TObjectPtr<class AActor> Target;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TViewTarget)
    struct FMinimalViewInfo POV;
 
protected:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=TViewTarget)
    TObjectPtr<class APlayerState> PlayerState;
 
public:
    class APlayerState* GetPlayerState() const { return PlayerState; }
    
    ENGINE_API void SetNewTarget(AActor* NewTarget);
 
    ENGINE_API class APawn* GetTargetPawn() const;
 
    ENGINE_API bool Equal(const FTViewTarget& OtherTarget) const;
 
    FTViewTarget()
        : Target(nullptr)
        , PlayerState(nullptr)
    {}
 
    ENGINE_API void CheckViewTarget(APlayerController* OwningController);
};
 
USTRUCT(BlueprintType)
struct FViewTargetTransitionParams
{
    GENERATED_USTRUCT_BODY()
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ViewTargetTransitionParams)
    float BlendTime;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ViewTargetTransitionParams)
    TEnumAsByte<enum EViewTargetBlendFunction> BlendFunction;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ViewTargetTransitionParams)
    float BlendExp;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ViewTargetTransitionParams)
    uint32 bLockOutgoing:1;
 
    FViewTargetTransitionParams()
        : BlendTime(0.f)
        , BlendFunction(VTBlend_Cubic)
        , BlendExp(2.f)
        , bLockOutgoing(false)
    {}
 
    float GetBlendAlpha(const float& TimePct) const
    {
        switch (BlendFunction)
        {
        case VTBlend_Linear: return FMath::Lerp(0.f, 1.f, TimePct); 
        case VTBlend_Cubic: return FMath::CubicInterp(0.f, 0.f, 1.f, 0.f, TimePct); 
        case VTBlend_EaseInOut: return FMath::InterpEaseInOut(0.f, 1.f, TimePct, BlendExp); 
        case VTBlend_EaseIn: return FMath::Lerp(0.f, 1.f, FMath::Pow(TimePct, BlendExp)); 
        case VTBlend_EaseOut: return FMath::Lerp(0.f, 1.f, FMath::Pow(TimePct, (FMath::IsNearlyZero(BlendExp) ? 1.f : (1.f / BlendExp))));
        case VTBlend_PreBlended:
        case VTBlend_MAX:
        default:
            break;
        }
 
        return 1.f;
    }
};
 
 
//~=============================================================================
UCLASS(notplaceable, transient, BlueprintType, Blueprintable, Config=Engine, MinimalAPI)
class APlayerCameraManager : public AActor
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(transient)
    TObjectPtr<class APlayerController> PCOwner;
 
private:
    UPROPERTY(Category = PlayerCameraManager, VisibleAnywhere, BlueprintReadOnly, meta = (AllowPrivateAccess = "true"))
    TObjectPtr<class USceneComponent> TransformComponent;
 
public:
    FName CameraStyle;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float DefaultFOV;
 
    float GetLockedFOV() const { return LockedFOV; }
 
protected:
    float LockedFOV;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float DefaultOrthoWidth;
 
protected:
    float LockedOrthoWidth;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float DefaultAspectRatio;
 
    FLinearColor FadeColor;
 
    float FadeAmount;
 
    FVector ColorScale;
 
    FVector DesiredColorScale;
 
    FVector OriginalColorScale;
 
    float ColorScaleInterpDuration;
 
    float ColorScaleInterpStartTime;
 
    UPROPERTY(transient)
    struct FTViewTarget ViewTarget;
 
    UPROPERTY(transient)
    struct FTViewTarget PendingViewTarget;
 
    float BlendTimeToGo;
 
    struct FViewTargetTransitionParams BlendParams;
 
public:
    DECLARE_EVENT(APlayerCameraManager, FOnBlendComplete)
    FOnBlendComplete& OnBlendComplete() const { return OnBlendCompleteEvent; }
private:
    mutable FOnBlendComplete OnBlendCompleteEvent;
private:
    UPROPERTY(transient)
    struct FCameraCacheEntry CameraCachePrivate;
 
    UPROPERTY(transient)
    struct FCameraCacheEntry LastFrameCameraCachePrivate;
 
protected:
    UPROPERTY(transient)
    TArray<TObjectPtr<UCameraModifier>> ModifierList;
 
public:
    ENGINE_API void ForEachCameraModifier(TFunctionRef<bool(UCameraModifier*)> Fn);
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = CameraModifier)
    TArray< TSubclassOf<UCameraModifier> > DefaultModifiers;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Debug)
    float FreeCamDistance;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Debug)
    FVector FreeCamOffset;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Debug)
    FVector ViewTargetOffset;
 
    UPROPERTY(BlueprintAssignable, Transient)
    FOnAudioFadeChangeSignature OnAudioFadeChangeEvent;
 
    FVector2D FadeAlpha;
 
    float FadeTime;
 
    float FadeTimeRemaining;
 
    ENGINE_API virtual void SetCameraCachePOV(const FMinimalViewInfo& InPOV);
    
    ENGINE_API virtual void SetLastFrameCameraCachePOV(const FMinimalViewInfo& InPOV);
 
    ENGINE_API virtual const FMinimalViewInfo& GetCameraCacheView() const;
 
    ENGINE_API virtual const FMinimalViewInfo& GetLastFrameCameraCacheView() const;
 
    float GetCameraCacheTime() const { return CameraCachePrivate.TimeStamp; }
 
    float GetLastFrameCameraCacheTime() const { return LastFrameCameraCachePrivate.TimeStamp; }
 
protected:
    void SetCameraCacheTime(float InTime) { CameraCachePrivate.TimeStamp = InTime; }
 
    void SetLastFrameCameraCacheTime(float InTime) { LastFrameCameraCachePrivate.TimeStamp = InTime; }
 
    // "Lens" effects (e.g. blood, dirt on camera)
    UPROPERTY(transient)
    TArray<TScriptInterface<class ICameraLensEffectInterface>> CameraLensEffects;
 
    // Camera Modifiers
 
    UPROPERTY(transient)
    TObjectPtr<class UCameraModifier_CameraShake> CachedCameraShakeMod;
 
 
    UPROPERTY(transient)
    TArray<struct FPostProcessSettings> PostProcessBlendCache;
 
    TArray<float> PostProcessBlendCacheWeights;
 
    TArray<EViewTargetBlendOrder> PostProcessBlendCacheOrders;
 
public:
    ENGINE_API void AddCachedPPBlend(struct FPostProcessSettings& PPSettings, float BlendWeight, EViewTargetBlendOrder BlendOrder = VTBlendOrder_Base);
 
    ENGINE_API void GetCachedPostProcessBlends(TArray<struct FPostProcessSettings> const*& OutPPSettings, TArray<float> const*& OutBlendWeights) const;
 
    ENGINE_API void GetCachedPostProcessBlends(TArray<struct FPostProcessSettings> const*& OutPPSettings, TArray<float> const*& OutBlendWeights, TArray<EViewTargetBlendOrder> const*& OutBlendOrders) const;
 
protected:
    ENGINE_API void ClearCachedPPBlends();
 
protected:
    UPROPERTY(transient)
    TObjectPtr<class ACameraActor> AnimCameraActor;
 
 
    // Flags
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PlayerCameraManager)
    uint32 bIsOrthographic : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PlayerCameraManager, meta = (EditCondition = "bIsOrthographic"))
    uint32 bAutoCalculateOrthoPlanes : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PlayerCameraManager, meta = (EditCondition = "bIsOrthographic && bAutoCalculateOrthoPlanes"))
    float AutoPlaneShift;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PlayerCameraManager, meta = (EditCondition = "bIsOrthographic"))
    uint32 bUpdateOrthoPlanes : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = PlayerCameraManager, meta = (EditCondition = "bIsOrthographic && bUpdateOrthoPlanes"))
    uint32 bUseCameraHeightAsViewTarget : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    uint32 bDefaultConstrainAspectRatio : 1;
 
    uint32 bEnableFading : 1;
 
    uint32 bFadeAudio : 1;
 
    uint32 bEnableColorScaling : 1;
 
    uint32 bEnableColorScaleInterp : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    uint32 bClientSimulatingViewTarget : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=PlayerCameraManager)
    uint32 bUseClientSideCameraUpdates : 1;
 
    uint32 bDebugClientSideCamera : 1;
 
    uint32 bShouldSendClientSideCameraUpdate : 1;
 
    UPROPERTY(Transient, BlueprintReadOnly, Category=PlayerCameraManager)
    uint32 bGameCameraCutThisFrame : 1;
 
protected:
    uint32 bHoldFadeWhenFinished : 1;
 
    uint32 bAutoAnimateFade : 1;
 
    uint32 bAlwaysApplyModifiers : 1;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewPitchMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewPitchMax;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewYawMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewYawMax;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewRollMin;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=PlayerCameraManager)
    float ViewRollMax;
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCosmetic, Category = "Photography")
    ENGINE_API void PhotographyCameraModify(const FVector NewCameraLocation, const FVector PreviousCameraLocation, const FVector OriginalCameraLocation, FVector& ResultCameraLocation);
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCosmetic, Category = "Photography")
    ENGINE_API void OnPhotographySessionStart();
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCosmetic, Category = "Photography")
    ENGINE_API void OnPhotographySessionEnd();
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCosmetic, Category = "Photography")
    ENGINE_API void OnPhotographyMultiPartCaptureStart();
 
    UFUNCTION(BlueprintNativeEvent, BlueprintCosmetic, Category = "Photography")
    ENGINE_API void OnPhotographyMultiPartCaptureEnd();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic)
    ENGINE_API bool BlueprintUpdateCamera(AActor* CameraTarget, FVector& NewCameraLocation, FRotator& NewCameraRotation, float& NewCameraFOV);
 
    UFUNCTION(BlueprintCallable, Category="Game|Player")
    ENGINE_API virtual APlayerController* GetOwningPlayerController() const;
 
    ENGINE_API virtual void AssignViewTarget(AActor* NewTarget, FTViewTarget& VT, struct FViewTargetTransitionParams TransitionParams=FViewTargetTransitionParams());
 
    friend struct FTViewTarget;
public:
    ENGINE_API AActor* GetViewTarget() const;
 
    ENGINE_API class APawn* GetViewTargetPawn() const;
 
    //~ Begin AActor Interface
    ENGINE_API virtual bool ShouldTickIfViewportsOnly() const override;
    ENGINE_API virtual void PostInitializeComponents() override;
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    ENGINE_API virtual void Destroyed() override;
    ENGINE_API virtual void DisplayDebug(class UCanvas* Canvas, const FDebugDisplayInfo& DebugDisplay, float& YL, float& YPos) override;
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
    //~ End AActor Interface
 
    static ENGINE_API void PlayWorldCameraShake(UWorld* InWorld, TSubclassOf<UCameraShakeBase> Shake, FVector Epicenter, float InnerRadius, float OuterRadius, float Falloff, bool bOrientShakeTowardsEpicenter = false);
 
protected:
    static ENGINE_API float CalcRadialShakeScale(class APlayerCameraManager* Cam, FVector Epicenter, float InnerRadius, float OuterRadius, float Falloff);
 
private:
    float TimeSinceLastServerUpdateCamera;
 
    UPROPERTY(Config)
    float ServerUpdateCameraTimeout;
 
public:
 
    ENGINE_API virtual void UpdateCamera(float DeltaTime);
 
    ENGINE_API virtual void UpdateCameraPhotographyOnly();
 
    UFUNCTION(BlueprintCallable, Category = "Game|Player", meta = (DeterminesOutputType = "ModifierClass"))
    ENGINE_API virtual UCameraModifier* AddNewCameraModifier(TSubclassOf<UCameraModifier> ModifierClass);
 
    UFUNCTION(BlueprintCallable, Category = "Game|Player", meta = (DeterminesOutputType = "ModifierClass"))
    ENGINE_API virtual UCameraModifier* FindCameraModifierByClass(TSubclassOf<UCameraModifier> ModifierClass);
 
    UFUNCTION(BlueprintCallable, Category = "Game|Player")
    ENGINE_API virtual bool RemoveCameraModifier(UCameraModifier* ModifierToRemove);
 
protected:
    ENGINE_API virtual bool AddCameraModifierToList(UCameraModifier* NewModifier);
 
    ENGINE_API virtual void CleanUpAnimCamera(const bool bDestroy);
 
public: 
    ENGINE_API virtual void ApplyCameraModifiers(float DeltaTime, FMinimalViewInfo& InOutPOV);
    
    ENGINE_API virtual void InitializeFor(class APlayerController* PC);
    
    UFUNCTION(BlueprintCallable, Category = "Camera")
    ENGINE_API virtual float GetFOVAngle() const;
    
    ENGINE_API virtual void SetFOV(float NewFOV);
 
    ENGINE_API virtual void UnlockFOV();
 
    ENGINE_API virtual bool IsOrthographic() const;
 
    ENGINE_API virtual float GetOrthoWidth() const;
 
    ENGINE_API virtual void SetOrthoWidth(float OrthoWidth);
 
    ENGINE_API virtual void UnlockOrthoWidth();
 
    ENGINE_API virtual void GetCameraViewPoint(FVector& OutCamLoc, FRotator& OutCamRot) const;
    
    UFUNCTION(BlueprintCallable, Category = "Camera", meta=(Keywords="View Direction"))
    ENGINE_API virtual FRotator GetCameraRotation() const;
 
    UFUNCTION(BlueprintCallable, Category = "Camera", meta=(Keywords="View Position"))
    ENGINE_API virtual FVector GetCameraLocation() const;
    
    ENGINE_API virtual void SetDesiredColorScale(FVector NewColorScale, float InterpTime);
    
protected:
    ENGINE_API virtual void DoUpdateCamera(float DeltaTime);
 
    ENGINE_API virtual bool UpdatePhotographyCamera(FMinimalViewInfo& NewPOV);
 
public:
    ENGINE_API virtual void UpdatePhotographyPostProcessing(FPostProcessSettings& InOutPostProcessing);
 
protected:
    ENGINE_API virtual bool AllowPhotographyMode() const;
    ENGINE_API virtual void ApplyAudioFade();
    ENGINE_API virtual void StopAudioFade();
    
    ENGINE_API FPOV BlendViewTargets(const FTViewTarget& A, const FTViewTarget& B, float Alpha);
    
public:
    ENGINE_API void FillCameraCache(const FMinimalViewInfo& NewInfo);
    
protected:
    ENGINE_API virtual void UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime);
 
    ENGINE_API virtual void UpdateCameraLensEffects( const FTViewTarget& OutVT );
 
public:
    ENGINE_API virtual void SetViewTarget(class AActor* NewViewTarget, FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams());
    
    ENGINE_API virtual void ProcessViewRotation(float DeltaTime, FRotator& OutViewRotation, FRotator& OutDeltaRot);
 
    //
    // Camera Lens Effects
    //
    
    ENGINE_API virtual TScriptInterface<class ICameraLensEffectInterface> FindGenericCameraLensEffect(UPARAM(meta=(MustImplement = "CameraLensEffectInterface")) TSubclassOf<AActor> LensEffectEmitterClass);
    
    UFUNCTION(BlueprintCallable, Category = "Camera")
    ENGINE_API virtual TScriptInterface<class ICameraLensEffectInterface> AddGenericCameraLensEffect(UPARAM(meta=(MustImplement = "CameraLensEffectInterface")) TSubclassOf<AActor> LensEffectEmitterClass);
    
    UFUNCTION(BlueprintCallable, Category = "Camera")
    ENGINE_API virtual void RemoveGenericCameraLensEffect(TScriptInterface<class ICameraLensEffectInterface> Emitter);
    
    UFUNCTION(BlueprintCallable, Category = "Camera")
    ENGINE_API virtual void ClearCameraLensEffects();
 
    //
    // Camera Shakes.
    //
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual UCameraShakeBase* StartCameraShake(TSubclassOf<UCameraShakeBase> ShakeClass, float Scale=1.f, ECameraShakePlaySpace PlaySpace = ECameraShakePlaySpace::CameraLocal, FRotator UserPlaySpaceRot = FRotator::ZeroRotator);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual UCameraShakeBase* StartCameraShakeFromSource(TSubclassOf<UCameraShakeBase> ShakeClass, UCameraShakeSourceComponent* SourceComponent, float Scale=1.f, ECameraShakePlaySpace PlaySpace = ECameraShakePlaySpace::CameraLocal, FRotator UserPlaySpaceRot = FRotator::ZeroRotator);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual void StopCameraShake(UCameraShakeBase* ShakeInstance, bool bImmediately = true);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual void StopAllInstancesOfCameraShake(TSubclassOf<UCameraShakeBase> Shake, bool bImmediately = true);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual void StopAllCameraShakes(bool bImmediately = true);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual void StopAllInstancesOfCameraShakeFromSource(TSubclassOf<UCameraShakeBase> Shake, UCameraShakeSourceComponent* SourceComponent, bool bImmediately = true);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Shakes")
    ENGINE_API virtual void StopAllCameraShakesFromSource(UCameraShakeSourceComponent* SourceComponent, bool bImmediately = true);
 
    ENGINE_API virtual UCameraShakeBase* StartCameraShake(TSubclassOf<UCameraShakeBase> ShakeClass, const FAddCameraShakeParams& Params);
 
    //
    //  Camera fades.
    //
 
    UFUNCTION(BlueprintCallable, Category = "Camera Fades")
    ENGINE_API virtual void StartCameraFade(float FromAlpha, float ToAlpha, float Duration, FLinearColor Color, bool bShouldFadeAudio = false, bool bHoldWhenFinished = false);
 
    UFUNCTION(BlueprintCallable, Category = "Camera Fades")
    ENGINE_API virtual void StopCameraFade();
 
    UFUNCTION(BlueprintCallable, Category = "Camera Fades")
    ENGINE_API virtual void SetManualCameraFade(float InFadeAmount, FLinearColor Color, bool bInFadeAudio);
 
 
    UFUNCTION(BlueprintCallable, Category = "Camera")
    virtual void SetGameCameraCutThisFrame() { bGameCameraCutThisFrame = true; }
 
public:
    ENGINE_API virtual void LimitViewPitch(FRotator& ViewRotation, float InViewPitchMin, float InViewPitchMax);
 
    ENGINE_API virtual void LimitViewRoll(FRotator& ViewRotation, float InViewRollMin, float InViewRollMax);
 
    ENGINE_API virtual void LimitViewYaw(FRotator& ViewRotation, float InViewYawMin, float InViewYawMax);
 
protected:
    ENGINE_API virtual void UpdateViewTargetInternal(FTViewTarget& OutVT, float DeltaTime);
 
    // ClientSide camera updates prevents DoUpdateCamera from swapping PendingViewTarget in when the blend is complete, just use a timer to swap
    UFUNCTION()
    ENGINE_API void SwapPendingViewTargetWhenUsingClientSideCameraUpdates();
 
    FTimerHandle SwapPendingViewTargetWhenUsingClientSideCameraUpdatesTimerHandle;
 
private:
    // Buried to prevent use; use GetCameraRotation instead
    FRotator GetActorRotation() const { return Super::GetActorRotation(); }
 
    // Buried to prevent use; use GetCameraLocation instead
    FVector GetActorLocation() const { return Super::GetActorLocation(); }
 
public:
    class USceneComponent* GetTransformComponent() const { return TransformComponent; }
};