file
function     bool UAvaGameViewportClient::GetProjectionData

		// Create the projection matrix (and possibly constrain the view rectangle)
		FMinimalViewInfo::CalculateProjectionMatrixGivenView(ViewInfo
			, GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint
			, InViewport
			, ProjectionData);

		for (const TSharedRef<ISceneViewExtension>& ViewExt : GEngine->ViewExtensions->GatherActiveExtensions(FSceneViewExtensionContext(InViewport)))
        {
			ViewExt->SetupViewProjectionMatrix(ProjectionData);

file
namespace    UE::Interchange::Private
function     FInterchangePropertyTracksHelper::FInterchangePropertyTracksHelper

			// Camera
			{UE::Interchange::Animation::PropertyTracks::Camera::AspectRatioAxisConstraint, {UMovieSceneByteTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCameraComponent, AspectRatioAxisConstraint), TEXT("Aspect Ratio Axis Constraint"), StaticEnum<EAspectRatioAxisConstraint>()}},
			{UE::Interchange::Animation::PropertyTracks::Camera::ConstrainAspectRatio, {UMovieSceneBoolTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCameraComponent, bConstrainAspectRatio), TEXT("Constrain Aspect Ratio")}},
			{UE::Interchange::Animation::PropertyTracks::Camera::CurrentAperture, {UMovieSceneFloatTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCineCameraComponent, CurrentAperture), TEXT("Current Aperture")}},
			{UE::Interchange::Animation::PropertyTracks::Camera::CurrentFocalLength, {UMovieSceneFloatTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCineCameraComponent, CurrentFocalLength), TEXT("Current Focal Length")}},
			{UE::Interchange::Animation::PropertyTracks::Camera::CustomNearClippingPlane, {UMovieSceneFloatTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCineCameraComponent, CustomNearClippingPlane), TEXT("Custom Near Clipping Plane")}},
			{UE::Interchange::Animation::PropertyTracks::Camera::FieldOfView, {UMovieSceneFloatTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCameraComponent, FieldOfView), TEXT("Field of View")}},
			{UE::Interchange::Animation::PropertyTracks::Camera::OrthoFarClipPlane, {UMovieSceneFloatTrack::StaticClass()->GetName(), GET_MEMBER_NAME_STRING_CHECKED(UCameraComponent, OrthoFarClipPlane), TEXT("Ortho Far Clip Plane")}},

file
namespace    UE
namespace    Interchange
namespace    Animation
namespace    PropertyTracks
namespace    Camera

				{
					const FName AutoActivate = TEXT("Camera.bAutoActivate");
					const FName AspectRatioAxisConstraint = TEXT("Camera.AspectRatioAxisConstraint");
					const FName ConstrainAspectRatio = TEXT("Camera.bConstrainAspectRatio");
					const FName CurrentAperture = TEXT("Camera.CurrentAperture");
					const FName CurrentFocalLength = TEXT("Camera.CurrentFocalLength");
					const FName CustomNearClippingPlane = TEXT("Camera.CustomNearClippingPlane");
					const FName FieldOfView = TEXT("Camera.FieldOfView");
					const FName Mobility = TEXT("Camera.Mobility");

file
namespace    UE::MovieGraph::Rendering
function     FMatrix FMovieGraphImagePassBase::CalculateProjectionMatrix

		else
		{
			const EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint;
			if (((ViewRectWidth > ViewRectHeight) && (AspectRatioAxisConstraint == AspectRatio_MajorAxisFOV)) || (AspectRatioAxisConstraint == AspectRatio_MaintainXFOV))
			{
				//if the viewport is wider than it is tall
				XAxisMultiplier = 1.0f;
				YAxisMultiplier = ViewRectWidth / ViewRectHeight;
			}
			else

file
function     FSceneView* UMoviePipelineImagePassBase::GetSceneViewForSampleState

				const int32 DestSizeX = ViewInitOptions.GetViewRect().Width();
				const int32 DestSizeY = ViewInitOptions.GetViewRect().Height();
				const EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint;
				if (((DestSizeX > DestSizeY) && (AspectRatioAxisConstraint == AspectRatio_MajorAxisFOV)) || (AspectRatioAxisConstraint == AspectRatio_MaintainXFOV))
				{
					//if the viewport is wider than it is tall
					XAxisMultiplier = 1.0f;
					YAxisMultiplier = ViewInitOptions.GetViewRect().Width() / (float)ViewInitOptions.GetViewRect().Height();
				}
				else

file
function     void FDisplayClusterLightCardEditorViewportClient::GetSceneViewInitOptions

		ViewTransform.GetLocation(),
		ViewTransform.GetRotation(),
		GetDefault<ULevelEditorViewportSettings>()->AspectRatioAxisConstraint,
		GetNearClipPlane(),
		&RotationMatrix,
		GetDPIScale()
	);

	ViewInitOptions.SceneViewStateInterface = ViewState.GetReference();

file
function     void FSequencer::UpdateLevelViewportClientsActorLocks

	}

	TOptional<EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
	if (LevelSequenceActor->CameraSettings.bOverrideAspectRatioAxisConstraint)
	{
		AspectRatioAxisConstraint = LevelSequenceActor->CameraSettings.AspectRatioAxisConstraint;
	}

	for (FLevelEditorViewportClient* LevelVC : GEditor->GetLevelViewportClients())
	{
		if (LevelVC != nullptr)
		{

file
function     void FSequencer::UpdateLevelViewportClientsActorLocks

				if (CachedCameraActors.Find(LockedActor))
				{
					ActorLock.AspectRatioAxisConstraint = AspectRatioAxisConstraint;
				}
			}
			// If we are in control of the entire viewport, also set the aspect ratio axis constraint.
			if (IsPerspectiveViewportCameraCutEnabled())
			{
				FLevelViewportActorLock& CinematicLock = LevelVC->GetCinematicActorLock();
				if (AActor* LockedActor = CinematicLock.GetLockedActor())
				{
					CinematicLock.AspectRatioAxisConstraint = AspectRatioAxisConstraint;
				}
			}
		}
	}
}

file
class        class ULevelEditorViewportSettings : public UObject

	/** How to constrain perspective view port FOV */
	UPROPERTY(EditAnywhere, config, Category=LookAndFeel)
	TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint;

	/** Enables real-time hover feedback when mousing over objects in editor view ports */
	UPROPERTY(EditAnywhere, config, Category=LookAndFeel, meta=(DisplayName = "Highlight Objects Under Mouse Cursor"))
	uint32 bEnableViewportHoverFeedback:1;

	/** If enabled, selected objects will be highlighted with brackets in all modes rather than a special highlight color. */

file
function     FSceneView* FEditorViewportClient::CalcSceneView

	const bool bConstrainAspectRatio = bUseControllingActorViewInfo && ControllingActorViewInfo.bConstrainAspectRatio;
	EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULevelEditorViewportSettings>()->AspectRatioAxisConstraint;
	if (bUseControllingActorViewInfo && ControllingActorAspectRatioAxisConstraint.IsSet())
	{
		AspectRatioAxisConstraint = ControllingActorAspectRatioAxisConstraint.GetValue();
	}

	AWorldSettings* WorldSettings = nullptr;
	if( GetScene() != nullptr && GetScene()->GetWorld() != nullptr )
	{
		WorldSettings = GetScene()->GetWorld()->GetWorldSettings();

file
function     FSceneView* FEditorViewportClient::CalcSceneView

			FPlane(0, 0, 0, 1));

		FMinimalViewInfo::CalculateProjectionMatrixGivenView(ControllingActorViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ViewInitOptions);
	}
	else
	{
		//
		if (EffectiveViewportType == LVT_Perspective)
		{

file
function     FSceneView* FEditorViewportClient::CalcSceneView

				    float YAxisMultiplier;

				    if (((ViewportSize.X > ViewportSize.Y) && (AspectRatioAxisConstraint == AspectRatio_MajorAxisFOV)) || (AspectRatioAxisConstraint == AspectRatio_MaintainXFOV))
				    {
					    //if the viewport is wider than it is tall
					    XAxisMultiplier = 1.0f;
					    YAxisMultiplier = ViewportSize.X / (float)ViewportSize.Y;
				    }
				    else

file
function     void FLevelEditorViewportClient::UpdateViewForLockedActor

						// Axis constraint for aspect ratio
						ControllingActorAspectRatioAxisConstraint = ActiveLock.AspectRatioAxisConstraint;
						
						// Post processing is handled by OverridePostProcessingSettings
						ViewFOV = ControllingActorViewInfo.FOV;
						AspectRatio = ControllingActorViewInfo.AspectRatio;
						SetViewLocation(ControllingActorViewInfo.Location);
						SetViewRotation(ControllingActorViewInfo.Rotation);

file
function     FLevelViewportActorLock

	/** Creates a new instance of FLevelViewportActorLock. */
	FLevelViewportActorLock(AActor* InActor, TOptional<EAspectRatioAxisConstraint> InAspectRatioAxisConstraint) 
		: LockedActor(InActor), AspectRatioAxisConstraint(InAspectRatioAxisConstraint) {}

	/** Returns whether the locked actor is valid. */
	bool HasValidLockedActor() const { return LockedActor.IsValid(); }

	/** Gets the locked actor. */
	AActor* GetLockedActor() const { return LockedActor.Get(); }

	/** An optional aspect ratio axis constraint to use when resizing the viewport. */
	TOptional<EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
};

/** */
class FLevelEditorViewportClient : public FEditorViewportClient
{
	friend class FActorElementLevelEditorViewportInteractionCustomization;

file
class        class UCameraComponent : public USceneComponent

	/** Override for the default aspect ratio axis constraint defined on the local player */
	UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions, meta = (EditCondition = "bOverrideAspectRatioAxisConstraint"))
	TEnumAsByte<EAspectRatioAxisConstraint> AspectRatioAxisConstraint = EAspectRatioAxisConstraint::AspectRatio_MaintainXFOV;
	UFUNCTION(BlueprintCallable, Category = Camera)
	void SetAspectRatioAxisConstraint(EAspectRatioAxisConstraint InAspectRatioAxisConstraint) { AspectRatioAxisConstraint = InAspectRatioAxisConstraint; }

	/** If bConstrainAspectRatio is true, black bars will be added if the destination view has a different aspect ratio than this camera requested. */
	UPROPERTY(Interp, EditAnywhere, BlueprintReadWrite, Category = CameraOptions)
	uint8 bConstrainAspectRatio : 1;
	UFUNCTION(BlueprintCallable, Category = Camera)
	void SetConstraintAspectRatio(bool bInConstrainAspectRatio) { bConstrainAspectRatio = bInConstrainAspectRatio; }

	// 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 true, account for the field of view angle when computing which level of detail to use for meshes.

	/** Calculates the projection matrix (and potentially a constrained view rectangle) given a FMinimalViewInfo and partially configured projection data (must have the view rect already set) */
	ENGINE_API static void CalculateProjectionMatrixGivenView(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, class FViewport* Viewport, struct FSceneViewProjectionData& InOutProjectionData);
	/** Calculates the projection matrix (and potentially a constrained view rectangle) given a FMinimalViewInfo and partially configured projection data (must have the view rect already set). ConstrainedViewRectangle is only used if the ViewInfo.bConstrainAspectRatio is set. */
	ENGINE_API static void CalculateProjectionMatrixGivenViewRectangle(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, const FIntRect& ConstrainedViewRectangle, FSceneViewProjectionData& InOutProjectionData);

	/** The near plane distance of the perspective view (in world units). Returns the value of PerspectiveNearClipPlane if positive, and GNearClippingPlane otherwise */
	FORCEINLINE float GetFinalPerspectiveNearClipPlane() const
	{
		return PerspectiveNearClipPlane > 0.0f ? PerspectiveNearClipPlane : GNearClippingPlane;
	}

file
class        class ULocalPlayer : public UPlayer

	/** How to constrain perspective viewport FOV */
	UPROPERTY(config)
	TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint;

	/** The class of PlayerController to spawn for players logging in. */
	UPROPERTY()
	TSubclassOf<class APlayerController> PendingLevelPlayerControllerClass;

	/** set when we've sent a split join request */

file
function     void UCameraComponent::GetCameraView

	if (bOverrideAspectRatioAxisConstraint)
	{
		DesiredView.AspectRatioAxisConstraint = AspectRatioAxisConstraint;
	}

	// See if the CameraActor wants to override the PostProcess settings used.
	DesiredView.PostProcessBlendWeight = PostProcessBlendWeight;
	if (PostProcessBlendWeight > 0.0f)
	{

file
function     void FMinimalViewInfo::CalculateProjectionMatrixGivenViewRectangle

}

void FMinimalViewInfo::CalculateProjectionMatrixGivenViewRectangle(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, const FIntRect& ConstrainedViewRectangle, FSceneViewProjectionData& InOutProjectionData)
{
#if !(UE_BUILD_SHIPPING)
	if (CVarDebugForceAllCamerasToOrtho.GetValueOnAnyThread())
	{
		ViewInfo.ProjectionMode = ECameraProjectionMode::Orthographic;
		ViewInfo.OrthoWidth = CVarDebugForceCameraOrthoWidth.GetValueOnAnyThread();

file
function     void FMinimalViewInfo::CalculateProjectionMatrixGivenViewRectangle

		// Get effective aspect ratio axis constraint.
		AspectRatioAxisConstraint = ViewInfo.AspectRatioAxisConstraint.Get(AspectRatioAxisConstraint);

		// If x is bigger, and we're respecting x or major axis, AND mobile isn't forcing us to be Y axis aligned
		const bool bMaintainXFOV = 
			((SizeX > SizeY) && ((AspectRatioAxisConstraint == AspectRatio_MajorAxisFOV) || (ViewInfo.ProjectionMode == ECameraProjectionMode::Orthographic))) ||
			(AspectRatioAxisConstraint == AspectRatio_MaintainXFOV);
		if (bMaintainXFOV)
		{
			// If the viewport is wider than it is tall
			XAxisMultiplier = 1.0f;
			YAxisMultiplier = SizeX / (float)SizeY;
		}

file
function     void FMinimalViewInfo::CalculateProjectionMatrixGivenView

}

void FMinimalViewInfo::CalculateProjectionMatrixGivenView(FMinimalViewInfo& ViewInfo, TEnumAsByte<enum EAspectRatioAxisConstraint> AspectRatioAxisConstraint, FViewport* Viewport, FSceneViewProjectionData& InOutProjectionData)
{
	FIntRect ViewExtents = Viewport->CalculateViewExtents(ViewInfo.AspectRatio, InOutProjectionData.GetViewRect());
	CalculateProjectionMatrixGivenViewRectangle(ViewInfo, AspectRatioAxisConstraint, ViewExtents, InOutProjectionData);
}

bool FMinimalViewInfo::AutoCalculateOrthoPlanes(FSceneViewProjectionData& InOutProjectionData)
{	
	if (ProjectionMode == ECameraProjectionMode::Orthographic && CVarOrthoAllowAutoPlanes.GetValueOnAnyThread() && bAutoCalculateOrthoPlanes)
	{

file
function     bool ULocalPlayer::GetProjectionData

	{
		// Create the projection matrix (and possibly constrain the view rectangle)
		FMinimalViewInfo::CalculateProjectionMatrixGivenView(ViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ProjectionData);

		for (auto& ViewExt : GEngine->ViewExtensions->GatherActiveExtensions(FSceneViewExtensionContext(Viewport)))
        {
			ViewExt->SetupViewProjectionMatrix(ProjectionData);
		};
	}

file
function     TOptional<EAspectRatioAxisConstraint> ALevelSequenceActor::GetAspectRatioAxisConstraint

TOptional<EAspectRatioAxisConstraint> ALevelSequenceActor::GetAspectRatioAxisConstraint() const
{
	TOptional<EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
	if (CameraSettings.bOverrideAspectRatioAxisConstraint)
	{
		AspectRatioAxisConstraint = CameraSettings.AspectRatioAxisConstraint;
	}
	return AspectRatioAxisConstraint;
}

bool ALevelSequenceActor::GetIsReplicatedPlayback() const
{
	return bReplicatePlayback;
}

file
function     TOptional<EAspectRatioAxisConstraint> ULevelSequencePlayer::GetAspectRatioAxisConstraintOverride

{
	return CameraSettings.bOverrideAspectRatioAxisConstraint ?
		TOptional<EAspectRatioAxisConstraint>(CameraSettings.AspectRatioAxisConstraint) :
		TOptional<EAspectRatioAxisConstraint>();
}

void ULevelSequencePlayer::OnCameraCutUpdated(const UE::MovieScene::FOnCameraCutUpdatedParams& Params)
{
	CachedCameraComponent = Params.ViewTargetCamera;

	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Aspect Ratio", meta = (EditCondition = bOverrideAspectRatioAxisConstraint))
	TEnumAsByte<EAspectRatioAxisConstraint> AspectRatioAxisConstraint = EAspectRatioAxisConstraint::AspectRatio_MaintainXFOV;
};

file
namespace    UE::MovieScene
function     FPreAnimatedCameraCutState FPreAnimatedCameraCutTraits::CachePreAnimatedValue

		// Save previous aspect ratio axis constraint.
		ULocalPlayer* LocalPlayer = (PC != nullptr) ? PC->GetLocalPlayer() : nullptr;
		TOptional<EAspectRatioAxisConstraint> AspectRatioAxisConstraint;
		if (LocalPlayer)
		{
			AspectRatioAxisConstraint = LocalPlayer->AspectRatioAxisConstraint;
		}

		return StorageType{ World, LocalPlayer, ViewTarget, AspectRatioAxisConstraint };
	}
	return StorageType();
}

void FPreAnimatedCameraCutTraits::RestorePreAnimatedValue(
		uint8 InKey, 

file
namespace    UE::MovieScene
function     void FPreAnimatedCameraCutTraits::RestorePreAnimatedValue

	if (LocalPlayer && CachedValue.LastAspectRatioAxisConstraint.IsSet())
	{
		LocalPlayer->AspectRatioAxisConstraint = CachedValue.LastAspectRatioAxisConstraint.GetValue();
	}
}

TAutoRegisterPreAnimatedStorageID<FPreAnimatedCameraCutStorage> FPreAnimatedCameraCutStorage::StorageID;

/** Utility function for converting sequence blend curves to camera manager blend types */

file
namespace    UE::MovieScene
function     void FCameraCutGameHandler::SetCameraCut

	if (LocalPlayer != nullptr && OverrideAspectRatioAxisConstraint.IsSet())
	{
		LocalPlayer->AspectRatioAxisConstraint = OverrideAspectRatioAxisConstraint.GetValue();
	}

	// We want to notify of cuts on hard cuts and time jumps, but not on blend cuts.
	const bool bIsStraightCut = !CameraCutParams.BlendType.IsSet() || CameraCutParams.bJumpCut;

	if (CameraComponent && bIsStraightCut)

file
function     FSceneView* FUMGViewportClient::CalcSceneView

	//@TODO: Should probably be locally configurable (or just made into a FMinimalViewInfo property)
	const EAspectRatioAxisConstraint AspectRatioAxisConstraint = GetDefault<ULocalPlayer>()->AspectRatioAxisConstraint;

	FMinimalViewInfo::CalculateProjectionMatrixGivenView(ViewInfo, AspectRatioAxisConstraint, Viewport, /*inout*/ ViewInitOptions);

	ViewInitOptions.ViewFamily = ViewFamily;
	ViewInitOptions.SceneViewStateInterface = ViewState.GetReference();
	ViewInitOptions.ViewElementDrawer = this;

	ViewInitOptions.BackgroundColor = GetBackgroundColor();