CameraTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "Engine/EngineTypes.h"
#include "EngineDefines.h"
#include "Engine/Scene.h"
#include "CameraTypes.generated.h"
 
class UCameraShakeSourceComponent;
 
//@TODO: Document
UENUM()
namespace ECameraProjectionMode
{
    enum Type : int
    {
        Perspective,
        Orthographic
    };
}
 
UENUM()
enum class ECameraShakePlaySpace : uint8
{
    CameraLocal,
    World,
    UserDefined,
};
 
USTRUCT(BlueprintType)
struct FMinimalViewInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    FVector Location;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    FRotator Rotation;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float FOV;
 
    UPROPERTY(Transient)
    float DesiredFOV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    float FirstPersonFOV;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    float FirstPersonScale;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float OrthoWidth;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    bool bAutoCalculateOrthoPlanes;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    float AutoPlaneShift;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    bool bUpdateOrthoPlanes;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    bool bUseCameraHeightAsViewTarget;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category=Camera)
    float OrthoNearClipPlane;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category=Camera)
    float OrthoFarClipPlane;
 
    UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category=Camera)
    float PerspectiveNearClipPlane;
 
    // Aspect Ratio (Width/Height)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float AspectRatio;
 
    // Aspect ratio axis constraint override
    TOptional<EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
 
    // If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested.
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    uint32 bConstrainAspectRatio:1; 
 
    // If bUseFirstPersonParameters is true, FirstPersonFOV and FirstPersonScale should be applied to primitives tagged as "IsFirstPerson".
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Camera)
    uint32 bUseFirstPersonParameters : 1;
 
    // If true, account for the field of view angle when computing which level of detail to use for meshes.
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category=CameraSettings)
    uint32 bUseFieldOfViewForLOD:1;
 
    // The type of camera
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    TEnumAsByte<ECameraProjectionMode::Type> ProjectionMode;
 
    UPROPERTY(BlueprintReadWrite, Category = Camera)
    float PostProcessBlendWeight;
 
    UPROPERTY(BlueprintReadWrite, Category = Camera)
    struct FPostProcessSettings PostProcessSettings;
 
    UPROPERTY(Transient, VisibleInstanceOnly, BlueprintReadWrite, Category = Camera)
    FVector2D OffCenterProjectionOffset;
 
    TOptional<FTransform> PreviousViewTransform;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera)
    float OverscanResolutionFraction;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera, meta=(ClampMin=0.0, UIMin=0.0, ClampMax=1.0, UIMax=1.0))
    float CropFraction;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Camera, meta=(ClampMin=0.0, UIMin=0.0, ClampMax=1.0, UIMax=1.0))
    FVector4f AsymmetricCropFraction;
    
private:
    float Overscan;
 
    FVector4f AsymmetricOverscan;
    
    // Only used for Ortho camera auto plane calculations, tells the Near plane of the extra distance that needs to be added.
    FVector CameraToViewTarget;
 
public:
 
    FMinimalViewInfo()
        : Location(ForceInit)
        , Rotation(ForceInit)
        , FOV(90.0f)
        , DesiredFOV(90.0f)
        , FirstPersonFOV(90.0f)
        , FirstPersonScale(1.0f)
        , OrthoWidth(512.0f)
        , bAutoCalculateOrthoPlanes(true)
        , AutoPlaneShift(0.0f)
        , bUpdateOrthoPlanes(false)
        , bUseCameraHeightAsViewTarget(false)
        , OrthoNearClipPlane(0.0f)
        , OrthoFarClipPlane(UE_OLD_WORLD_MAX)
        , PerspectiveNearClipPlane(-1.0f)
        , AspectRatio(1.33333333f)
        , bConstrainAspectRatio(false)
        , bUseFirstPersonParameters(false)
        , bUseFieldOfViewForLOD(true)
        , ProjectionMode(ECameraProjectionMode::Perspective)
        , PostProcessBlendWeight(0.0f)
        , OffCenterProjectionOffset(ForceInitToZero)
        , OverscanResolutionFraction(1.0f)
        , CropFraction(1.0f)
        , AsymmetricCropFraction(FVector4f::One())
        , Overscan(0.0f)
        , AsymmetricOverscan(FVector4f::Zero())
        , CameraToViewTarget(FVector::ZeroVector)
    {
    }
 
    // Is this equivalent to the other one?
    ENGINE_API bool Equals(const FMinimalViewInfo& OtherInfo) const;
 
    // Blends view information
    // Note: booleans are orred together, instead of blending
    ENGINE_API void BlendViewInfo(FMinimalViewInfo& OtherInfo, float OtherWeight);
 
    ENGINE_API void ApplyBlendWeight(const float& Weight);
 
    ENGINE_API void AddWeightedViewInfo(const FMinimalViewInfo& OtherView, const float& Weight);
 
    ENGINE_API FMatrix CalculateProjectionMatrix() const;
 
    ENGINE_API static void CalculateProjectionMatrixGivenView(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, class FViewport* Viewport, struct FSceneViewProjectionData& InOutProjectionData);
    ENGINE_API static void CalculateProjectionMatrixGivenViewRectangle(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, const FIntRect& ConstrainedViewRectangle, FSceneViewProjectionData& InOutProjectionData);
 
    inline float GetFinalPerspectiveNearClipPlane() const
    {
        return PerspectiveNearClipPlane > 0.0f ? PerspectiveNearClipPlane : GNearClippingPlane;
    }
 
    ENGINE_API bool AutoCalculateOrthoPlanes(FSceneViewProjectionData& InOutProjectionData);
 
    inline void SetCameraToViewTarget(const FVector ActorLocation)
    {
        CameraToViewTarget = ActorLocation - Location;
    }
 
    ENGINE_API FVector TransformWorldToFirstPerson(const FVector& WorldPosition, bool bIgnoreFirstPersonScale) const;
 
    ENGINE_API float CalculateFirstPersonFOVCorrectionFactor() const;
 
    ENGINE_API void ApplyOverscan(float InOverscan, bool bScaleResolutionWithOverscan = false, bool bCropOverscan = false);
 
    ENGINE_API void ApplyAsymmetricOverscan(const FVector4f& InAsymmetricOverscan, bool bScaleResolutionWithOverscan = false, bool bCropOverscan = false);
    
    float GetOverscan() const { return Overscan; }
    
    ENGINE_API void ClearOverscan();
};