CameraComponent.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 "UObject/ScriptInterface.h"
#include "Components/SceneComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Engine/BlendableInterface.h"
#include "Engine/Scene.h"
#include "Camera/CameraTypes.h"
#include "CameraComponent.generated.h"
 
class UStaticMesh;
 
UCLASS(MinimalAPI)
class UCameraProxyMeshComponent : public UStaticMeshComponent
{
    GENERATED_BODY()
 
public:
    virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
};
 
UCLASS(HideCategories=(Mobility, Rendering, LOD), Blueprintable, ClassGroup=Camera, meta=(BlueprintSpawnableComponent), MinimalAPI)
class UCameraComponent : public USceneComponent
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (UIMin = "5.0", UIMax = "170", ClampMin = "0.001", ClampMax = "360.0", Units = deg))
    float FieldOfView;
    UFUNCTION(BlueprintCallable, Category = Camera)
    virtual void SetFieldOfView(float InFieldOfView) { FieldOfView = InFieldOfView; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (UIMin = "5.0", UIMax = "170", ClampMin = "0.001", ClampMax = "360.0", Units = deg, EditCondition = "bEnableFirstPersonFieldOfView"))
    float FirstPersonFieldOfView;
    UFUNCTION(BlueprintCallable, Category = Camera)
    virtual void SetFirstPersonFieldOfView(float InFirstPersonFieldOfView) { FirstPersonFieldOfView = InFirstPersonFieldOfView; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (UIMin = "0.001", UIMax = "1.0", ClampMin = "0.001", ClampMax = "1.0", EditCondition = "bEnableFirstPersonScale"))
    float FirstPersonScale;
    UFUNCTION(BlueprintCallable, Category = Camera)
    virtual void SetFirstPersonScale(float InFirstPersonScale) { FirstPersonScale = InFirstPersonScale; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings)
    float OrthoWidth;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetOrthoWidth(float InOrthoWidth) { OrthoWidth = InOrthoWidth; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings)
    bool bAutoCalculateOrthoPlanes;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetAutoCalculateOrthoPlanes(bool bAutoCalculate) { bAutoCalculateOrthoPlanes = bAutoCalculate; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (EditCondition = "bAutoCalculateOrthoPlanes"))
    float AutoPlaneShift;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetAutoPlaneShift(float InAutoPlaneShift) { AutoPlaneShift = InAutoPlaneShift; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (EditCondition = "!bAutoCalculateOrthoPlanes"))
    float OrthoNearClipPlane;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetOrthoNearClipPlane(float InOrthoNearClipPlane) { OrthoNearClipPlane = InOrthoNearClipPlane; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (EditCondition = "!bAutoCalculateOrthoPlanes"))
    float OrthoFarClipPlane;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetOrthoFarClipPlane(float InOrthoFarClipPlane) { OrthoFarClipPlane = InOrthoFarClipPlane; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings)
    bool bUpdateOrthoPlanes;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetUpdateOrthoPlanes(bool bInUpdateOrthoPlanes) { bUpdateOrthoPlanes = bInUpdateOrthoPlanes; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (EditCondition = "bUpdateOrthoPlanes"))
    bool bUseCameraHeightAsViewTarget;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetUseCameraHeightAsViewTarget(bool bInUseCameraHeightAsViewTarget) { bUseCameraHeightAsViewTarget = bInUseCameraHeightAsViewTarget; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings, meta = (ClampMin = "0.1", ClampMax = "100.0", EditCondition = "bConstrainAspectRatio"))
    float AspectRatio;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetAspectRatio(float InAspectRatio) { AspectRatio = InAspectRatio; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions, meta = (EditCondition = "!bConstrainAspectRatio && bOverrideAspectRatioAxisConstraint"))
    TEnumAsByte<EAspectRatioAxisConstraint> AspectRatioAxisConstraint = EAspectRatioAxisConstraint::AspectRatio_MaintainXFOV;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetAspectRatioAxisConstraint(EAspectRatioAxisConstraint InAspectRatioAxisConstraint) { AspectRatioAxisConstraint = InAspectRatioAxisConstraint; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bConstrainAspectRatio : 1;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetConstraintAspectRatio(bool bInConstrainAspectRatio) { bConstrainAspectRatio = bInConstrainAspectRatio; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bOverrideAspectRatioAxisConstraint : 1;
 
    // If true, account for the field of view angle when computing which level of detail to use for meshes.
    UPROPERTY(Interp, EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = CameraOptions)
    uint8 bUseFieldOfViewForLOD : 1;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetUseFieldOfViewForLOD(bool bInUseFieldOfViewForLOD) { bUseFieldOfViewForLOD = bInUseFieldOfViewForLOD; }
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions, meta = (UIMin="0.0", ClampMin="0.0", UIMax="1.0", ClampMax="1.0"))
    float Overscan;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetOverscan(float InOverscan) { Overscan = InOverscan; }
 
    UPROPERTY(meta = (UIMin="0.0", ClampMin="0.0", UIMax="1.0", ClampMax="1.0"))
    FVector4f AsymmetricOverscan = FVector4f::Zero();
    UFUNCTION()
    void SetAsymmetricOverscan(const FVector4f& InAsymmetricOverscan) { AsymmetricOverscan = InAsymmetricOverscan; }
    
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    bool bScaleResolutionWithOverscan;
 
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetScaleResolutionWithOverscan(bool bInScaleResolutionWithOverscan) { bScaleResolutionWithOverscan = bInScaleResolutionWithOverscan; }
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    bool bCropOverscan;
 
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetCropOverscan(bool bInCropOverscan) { bCropOverscan = bInCropOverscan; }
 
#if WITH_EDITOR
    // Returns the filmback text used for burnins on preview viewports
    UFUNCTION()
    ENGINE_API virtual FText GetFilmbackText() const;
#endif
 
#if WITH_EDITORONLY_DATA
    // The Frustum visibility flag for draw frustum component initialization
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    bool bDrawFrustumAllowed = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    uint8 bCameraMeshHiddenInGame : 1;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bLockToHmd : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bUsePawnControlRotation : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bEnableFirstPersonFieldOfView : 1;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetEnableFirstPersonFieldOfView(bool bInEnableFirstPersonFieldOfView) { bEnableFirstPersonFieldOfView = bInEnableFirstPersonFieldOfView; }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
    uint8 bEnableFirstPersonScale : 1;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetEnableFirstPersonScale(bool bInEnableFirstPersonScale) { bEnableFirstPersonScale = bInEnableFirstPersonScale; }
 
protected:
    uint8 bUseAdditiveOffset : 1;
 
public:
    // The type of camera
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraSettings)
    TEnumAsByte<ECameraProjectionMode::Type> ProjectionMode;
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetProjectionMode(ECameraProjectionMode::Type InProjectionMode) { ProjectionMode = InProjectionMode; }
 
    UFUNCTION(BlueprintCallable, Category = Camera)
    void SetPostProcessBlendWeight(float InPostProcessBlendWeight) { PostProcessBlendWeight = InPostProcessBlendWeight; }
 
    // UActorComponent interface
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUpdateTransform(EUpdateTransformFlags UpdateTransformFlags, ETeleportType Teleport) override;
#if WITH_EDITOR
    ENGINE_API virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;
    ENGINE_API virtual void OnComponentDestroyed(bool bDestroyingHierarchy) override;
    ENGINE_API virtual void CheckForErrors() override;
#endif
    // End of UActorComponent interface
 
    // USceneComponent interface
#if WITH_EDITOR
    ENGINE_API virtual bool GetEditorPreviewInfo(float DeltaTime, FMinimalViewInfo& ViewOut) override;
#endif 
    // End of USceneComponent interface
 
    // UObject interface
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#endif
    // End of UObject interface
 
protected:
    ENGINE_API bool IsXRHeadTrackedCamera() const;
    ENGINE_API virtual void HandleXRCamera(float DeltaTime);
 
public:
    UFUNCTION(BlueprintCallable, Category = Camera)
    ENGINE_API virtual void GetCameraView(float DeltaTime, FMinimalViewInfo& DesiredView);
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    void AddOrUpdateBlendable(TScriptInterface<IBlendableInterface> InBlendableObject, float InWeight = 1.0f) { PostProcessSettings.AddBlendable(InBlendableObject, InWeight); }
 
    UFUNCTION(BlueprintCallable, Category = "Rendering")
    void RemoveBlendable(TScriptInterface<IBlendableInterface> InBlendableObject) { PostProcessSettings.RemoveBlendable(InBlendableObject); }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void SetCameraMesh(UStaticMesh* Mesh);
#endif 
 
protected:
 
#if WITH_EDITORONLY_DATA
    // The frustum component used to show visually where the camera field of view is
    TObjectPtr<class UDrawFrustumComponent> DrawFrustum;
 
    UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = Camera)
    TObjectPtr<class UStaticMesh> CameraMesh;
 
    // The camera mesh to show visually where the camera is placed
    TObjectPtr<class UStaticMeshComponent> ProxyMeshComponent;
 
    ENGINE_API virtual void ResetProxyMeshTransform();
 
    ENGINE_API void UpdateProxyMeshTransform();
 
    /* Update draw frustum values */
    ENGINE_API void UpdateDrawFrustum();
 
#endif  // WITH_EDITORONLY_DATA
 
    UFUNCTION(BlueprintSetter)
    ENGINE_API void OnCameraMeshHiddenChanged();
 
    FTransform AdditiveOffset;
 
public:
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = PostProcess, meta = (UIMin = "0.0", UIMax = "1.0"))
    float PostProcessBlendWeight;
 
protected:
    float AdditiveFOVOffset;
 
    TArray<FPostProcessSettings> ExtraPostProcessBlends;
    TArray<float> ExtraPostProcessBlendWeights;
 
public:
 
    ENGINE_API void AddAdditiveOffset(FTransform const& Transform, float FOV);
    ENGINE_API void ClearAdditiveOffset();
    ENGINE_API void GetAdditiveOffset(FTransform& OutAdditiveOffset, float& OutAdditiveFOVOffset) const;
 
    ENGINE_API void AddExtraPostProcessBlend(FPostProcessSettings const& PPSettings, float PPBlendWeight);
    ENGINE_API void ClearExtraPostProcessBlends();
    ENGINE_API void GetExtraPostProcessBlends(TArray<FPostProcessSettings>& OutSettings, TArray<float>& OutWeights) const;
 
    ENGINE_API virtual void NotifyCameraCut();
 
public:
 
    UPROPERTY(Interp, BlueprintReadWrite, Category = PostProcess, meta=(ShowOnlyInnerProperties))
    struct FPostProcessSettings PostProcessSettings;
 
#if WITH_EDITORONLY_DATA
    // Refreshes the visual components to match the component state
    ENGINE_API virtual void RefreshVisualRepresentation();
 
    ENGINE_API void OverrideFrustumColor(FColor OverrideColor);
    ENGINE_API void RestoreFrustumColor();
 
public:
    UPROPERTY()
    uint32 bUseControllerViewRotation_DEPRECATED:1;
#endif  // WITH_EDITORONLY_DATA
};