Ue Gameplay Cameras

UE Gameplay Cameras

Target engine: UE 5.8. APIs below are verified against the 5.8 headers; older forms are listed under "Deprecated — do not use".

Two camera stacks ship in 5.8. The classic stack lives in the Engine module (Classes/Camera, Classes/GameFramework/SpringArmComponent.h) with shake patterns in the EngineCameras plugin and film-style cameras in CinematicCamera; the data-driven Gameplay Camera System lives in the GameplayCameras plugin (Experimental in 5.8, but enabled by default). Build.cs needs "Core", "CoreUObject", "Engine", plus "CinematicCamera" for cine cameras, "EngineCameras" for shake patterns, and "GameplayCameras" for the plugin.

Context

Read .agents/ue-project-context.md if it exists (module names, conventions, enabled plugins, GAS/networking setup). Do not stop if it is missing.

Identify the area from the request and the codebase. Ask only when two plausible readings would produce different code.

Full classic API surface (post-process on cameras, FMinimalViewInfo fields, shake pattern catalogue, cine camera settings): references/classic-camera-stack.md. Node/director/service catalogue, camera variables, evaluation contexts and CVars: references/gameplay-camera-system.md.

Classic Stack or Gameplay Camera System

Mixing is supported: AGameplayCamerasPlayerCameraManager is an APlayerCameraManager subclass, so classic view targets, fades and modifiers still work while the plugin runs the evaluation.

How the Classic Pipeline Runs

1. APlayerController holds PlayerCameraManager (spawned by virtual void SpawnPlayerCameraManager() from TSubclassOf<APlayerCameraManager> PlayerCameraManagerClass).
2. APlayerCameraManager::UpdateCamera(float DeltaTime) → DoUpdateCamera(float DeltaTime) → UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime).
3. UpdateViewTarget fills OutVT.POV (an FMinimalViewInfo). An ACameraActor target uses its camera component directly; any other target gets Target->CalcCamera (PlayerCameraManager.cpp:354), whose base AActor implementation uses the first active camera component when bFindCameraComponentWhenViewTarget is true, else the actor's eyes viewpoint (Actor.cpp:3688-3706).
4. ApplyCameraModifiers(float DeltaTime, FMinimalViewInfo& InOutPOV) runs every UCameraModifier in ModifierList by Priority (0 = highest).
5. The result is cached; GetCameraLocation(), GetCameraRotation() and GetCameraCacheView() read it, and APlayerController::GetPlayerViewPoint(FVector& out_Location, FRotator& out_Rotation) returns it.

bAutoManageActiveCameraTarget on APlayerController (default true) makes possession call virtual void AutoManageActiveCameraTarget(AActor* SuggestedTarget), which is why a freshly possessed pawn becomes the view target with no code.

Third-Person Spring Arm Camera

// MyCharacter.h
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h"

class UCameraComponent;
class USpringArmComponent;

UCLASS()
class MYGAME_API AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

private:
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera", meta = (AllowPrivateAccess = "true"))
    TObjectPtr<USpringArmComponent> CameraBoom;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera", meta = (AllowPrivateAccess = "true"))
    TObjectPtr<UCameraComponent> FollowCamera;
};

// MyCharacter.cpp - also include Camera/CameraComponent.h,
// GameFramework/SpringArmComponent.h and GameFramework/CharacterMovementComponent.h
#include "MyCharacter.h"

AMyCharacter::AMyCharacter()
{
    bUseControllerRotationPitch = false;
    bUseControllerRotationYaw   = false;
    bUseControllerRotationRoll  = false;

    GetCharacterMovement()->bOrientRotationToMovement = true;
    GetCharacterMovement()->RotationRate = FRotator(0.f, 500.f, 0.f);

    CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
    CameraBoom->SetupAttachment(RootComponent);
    CameraBoom->TargetArmLength = 400.f;
    CameraBoom->bUsePawnControlRotation = true;
    CameraBoom->bInheritPitch = true;
    CameraBoom->bInheritYaw = true;
    CameraBoom->bInheritRoll = false;
    CameraBoom->SocketOffset = FVector(0.f, 60.f, 0.f);
    CameraBoom->TargetOffset = FVector(0.f, 0.f, 50.f);
    CameraBoom->bDoCollisionTest = true;
    CameraBoom->ProbeChannel = ECC_Camera;
    CameraBoom->ProbeSize = 12.f;
    CameraBoom->bEnableCameraLag = true;
    CameraBoom->CameraLagSpeed = 10.f;
    CameraBoom->CameraLagMaxDistance = 100.f;

    FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
    FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
    FollowCamera->bUsePawnControlRotation = false;
    FollowCamera->FieldOfView = 90.f;
}

SocketOffset is applied in the boom's rotated space (side offsets follow the camera); TargetOffset is applied in world space (height offsets stay vertical). bUsePawnControlRotation belongs on exactly one of boom or camera — putting it on both double-applies the control rotation. Read the rotation the boom inherits (parent or control rotation) with FRotator GetTargetRotation() const, and test whether the collision probe pulled the arm in with bool IsCollisionFixApplied() const.

First-Person Camera

Attach the UCameraComponent directly to the mesh or capsule, set bUsePawnControlRotation = true on the camera, and leave bUseControllerRotationYaw = true on the pawn so the body turns with the view.

// MyFirstPersonCharacter.h - inside the class body
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Camera")
TObjectPtr<UCameraComponent> FirstPersonCamera;

// MyFirstPersonCharacter.cpp - also include Camera/CameraComponent.h and Components/CapsuleComponent.h
AMyFirstPersonCharacter::AMyFirstPersonCharacter()
{
    bUseControllerRotationYaw = true;

    FirstPersonCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
    FirstPersonCamera->SetupAttachment(GetCapsuleComponent());
    FirstPersonCamera->SetRelativeLocation(FVector(0.f, 0.f, BaseEyeHeight));
    FirstPersonCamera->bUsePawnControlRotation = true;
    FirstPersonCamera->bEnableFirstPersonFieldOfView = true;
    FirstPersonCamera->bEnableFirstPersonScale = true;
    FirstPersonCamera->FirstPersonFieldOfView = 70.f;
    FirstPersonCamera->FirstPersonScale = 0.6f;
}

FirstPersonFieldOfView and FirstPersonScale only affect primitives tagged as first person, and both need their bEnable* flag set. APawn::BaseEyeHeight feeds virtual FVector GetPawnViewLocation() const; override virtual void RecalculateBaseEyeHeight() for crouch. virtual FRotator GetViewRotation() const is the aim rotation used by the spring arm and by AI perception. To compute the view yourself, override AActor::CalcCamera and do not call Super — your override always runs for a non-ACameraActor view target; the camera-component lookup lives in the base implementation (Actor.cpp:3690). Set bFindCameraComponentWhenViewTarget = false only when you do call Super and want it to skip the component.

// MyViewTargetActor.cpp - declare the override in the class body, include Camera/CameraTypes.h
void AMyViewTargetActor::CalcCamera(float DeltaTime, struct FMinimalViewInfo& OutResult)
{
    OutResult.Location = GetActorLocation() + FVector(0.f, 0.f, 150.f);
    OutResult.Rotation = GetActorRotation();
    OutResult.FOV = 75.f;
}

View Targets and Blending

// Inside a method of a MyGame class that has a PlayerController - include GameFramework/PlayerController.h
void AMyPlayerController::FocusOnActor(AActor* NewTarget)
{
    SetViewTargetWithBlend(NewTarget, 0.75f, VTBlend_EaseInOut, 2.f, false);
}

virtual void SetViewTargetWithBlend(class AActor* NewViewTarget, float BlendTime = 0, enum EViewTargetBlendFunction BlendFunc = VTBlend_Linear, float BlendExp = 0, bool bLockOutgoing = false) is the call to reach for. EViewTargetBlendFunction values: VTBlend_Linear, VTBlend_Cubic, VTBlend_EaseIn, VTBlend_EaseOut, VTBlend_EaseInOut, VTBlend_PreBlended. BlendExp only matters for the three ease functions. bLockOutgoing freezes the old target's POV for the rest of the blend — use it when you are about to teleport or destroy it.

The manager-level form is virtual void SetViewTarget(class AActor* NewViewTarget, FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams()), where FViewTargetTransitionParams carries BlendTime, BlendFunction, BlendExp and bLockOutgoing. During a blend the manager holds ViewTarget and PendingViewTarget (both FTViewTarget, each with Target and POV) and counts down BlendTimeToGo; OnBlendComplete() fires when the pending target is promoted.

SetViewTarget and SetViewTargetWithBlend act on the calling machine's camera manager only — they do not replicate. To change one client's view from the server, call the client RPC UFUNCTION(Reliable, Client) void ClientSetViewTarget(class AActor* A, struct FViewTargetTransitionParams TransitionParams = FViewTargetTransitionParams()).

Custom APlayerCameraManager

// MyCameraManager.h
#pragma once

#include "CoreMinimal.h"
#include "Camera/PlayerCameraManager.h"
#include "MyCameraManager.generated.h"

UCLASS()
class MYGAME_API AMyCameraManager : public APlayerCameraManager
{
    GENERATED_BODY()

public:
    AMyCameraManager(const FObjectInitializer& ObjectInitializer);

protected:
    virtual void UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime) override;

    UPROPERTY(EditDefaultsOnly, Category = "Aim")
    float AimFieldOfView = 55.f;
    UPROPERTY(BlueprintReadWrite, Category = "Aim")
    bool bIsAiming = false;
};

// MyCameraManager.cpp
#include "MyCameraManager.h"

AMyCameraManager::AMyCameraManager(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    ViewPitchMin = -70.f;
    ViewPitchMax = 55.f;
    DefaultFOV = 90.f;
}

void AMyCameraManager::UpdateViewTarget(FTViewTarget& OutVT, float DeltaTime)
{
    Super::UpdateViewTarget(OutVT, DeltaTime);

    if (bIsAiming)
    {
        OutVT.POV.FOV = AimFieldOfView;
    }
}

Register it with PlayerCameraManagerClass = AMyCameraManager::StaticClass(); in the APlayerController constructor. Other hooks worth knowing: virtual void InitializeFor(class APlayerController* PC), virtual void ProcessViewRotation(float DeltaTime, FRotator& OutViewRotation, FRotator& OutDeltaRot), and the clamp helpers LimitViewPitch, LimitViewYaw, LimitViewRoll.

Fades run off the manager: virtual void StartCameraFade(float FromAlpha, float ToAlpha, float Duration, FLinearColor Color, bool bShouldFadeAudio = false, bool bHoldWhenFinished = false), virtual void StopCameraFade(), and virtual void SetManualCameraFade(float InFadeAmount, FLinearColor Color, bool bInFadeAudio) when you drive the alpha yourself. APlayerController::ClientSetCameraFade is the replicated wrapper.

Camera Modifiers

A modifier is a stateful object that post-processes the computed POV every frame — lean, recoil, breathing, lock-on nudges.

// MyCameraModifier.h
#pragma once

#include "CoreMinimal.h"
#include "Camera/CameraModifier.h"
#include "MyCameraModifier.generated.h"

UCLASS()
class MYGAME_API UMyCameraModifier : public UCameraModifier
{
    GENERATED_BODY()

public:
    UMyCameraModifier(const FObjectInitializer& ObjectInitializer);

    virtual bool ModifyCamera(float DeltaTime, struct FMinimalViewInfo& InOutPOV) override;

    UPROPERTY(EditDefaultsOnly, Category = "Lean")
    float LeanRollDegrees = 8.f;
};

// MyCameraModifier.cpp
#include "MyCameraModifier.h"
#include "Camera/CameraTypes.h"   // FMinimalViewInfo is only forward-declared by CameraModifier.h

UMyCameraModifier::UMyCameraModifier(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    Priority = 10;
    AlphaInTime = 0.2f;
    AlphaOutTime = 0.3f;
}

bool UMyCameraModifier::ModifyCamera(float DeltaTime, struct FMinimalViewInfo& InOutPOV)
{
    Super::ModifyCamera(DeltaTime, InOutPOV);

    InOutPOV.Rotation.Roll += LeanRollDegrees * Alpha;
    return false;
}

Return true only to stop lower-priority modifiers from running. Alpha is driven by virtual void UpdateAlpha(float DeltaTime) from AlphaInTime/AlphaOutTime; virtual float GetTargetAlpha() decides the destination. Toggle with virtual void EnableModifier(), virtual void DisableModifier(bool bImmediate = false) and virtual void ToggleModifier(); virtual bool IsDisabled() const reports state.

Add modifiers declaratively through TArray<TSubclassOf<UCameraModifier>> DefaultModifiers on the manager, or at runtime with virtual UCameraModifier* AddNewCameraModifier(TSubclassOf<UCameraModifier> ModifierClass), which instantiates, registers and returns it. virtual UCameraModifier* FindCameraModifierByClass(TSubclassOf<UCameraModifier> ModifierClass) retrieves one later; virtual bool RemoveCameraModifier(UCameraModifier* ModifierToRemove) drops it. virtual bool ProcessViewRotation(class AActor* ViewTarget, float DeltaTime, FRotator& OutViewRotation, FRotator& OutDeltaRot) lets a modifier alter the player's aim before the POV is built.

Camera Shakes

UCameraShakeBase is a thin container; the motion lives in its RootShakePattern (a UCameraShakePattern). In C++ you subclass a pattern — usually USimpleCameraShakePattern, which already supplies Duration, BlendInTime and BlendOutTime — and override virtual void UpdateShakePatternImpl(const FCameraShakePatternUpdateParams& Params, FCameraShakePatternUpdateResult& OutResult), writing into OutResult.Location, OutResult.Rotation and OutResult.FOV; advance the inherited State with State.Update(Params.DeltaTime) and scale by the weight it returns, or the shake never finishes. Full worked example: references/classic-camera-stack.md. The other pattern hooks, all on UCameraShakePattern, are GetShakePatternInfoImpl(FCameraShakeInfo& OutInfo) const, StartShakePatternImpl(const FCameraShakePatternStartParams& Params), ScrubShakePatternImpl(const FCameraShakePatternScrubParams& Params, FCameraShakePatternUpdateResult& OutResult), IsFinishedImpl() const, StopShakePatternImpl(const FCameraShakePatternStopParams& Params) and TeardownShakePatternImpl().

Shipped patterns (module "EngineCameras"): UPerlinNoiseCameraShakePattern, UWaveOscillatorCameraShakePattern, UCompositeCameraShakePattern, plus ULegacyCameraShakePattern behind ULegacyCameraShake. USequenceCameraShakePattern drives a shake from a UCameraAnimationSequence and lives in the TemplateSequence plugin. UDefaultCameraShakeBase is a UCameraShakeBase whose root pattern defaults to Perlin noise — the usual Blueprint starting point. Playing a shake:

Stop with APlayerController::ClientStopCameraShake(TSubclassOf<class UCameraShakeBase> Shake, bool bImmediately = true), APlayerCameraManager::StopAllCameraShakes(bool bImmediately = true) or StopAllCameraShakesFromSource(UCameraShakeSourceComponent* SourceComponent, bool bImmediately = true). ECameraShakePlaySpace is CameraLocal, World or UserDefined. UCameraShakeSourceComponent carries Attenuation (ECameraShakeAttenuation), InnerAttenuationRadius, OuterAttenuationRadius, CameraShake and bAutoStart; ACameraShakeSourceActor is the placeable wrapper.

Shakes are applied by UCameraModifier_CameraShake, which the manager creates by default; virtual UCameraShakeBase* AddCameraShake(TSubclassOf<UCameraShakeBase> NewShake, const FAddCameraShakeParams& Params) is the low-level entry when you need FAddCameraShakeParams::DurationOverride or a custom initializer.

Cinematic Cameras

UCineCameraComponent extends UCameraComponent with physical-camera settings: Filmback (FCameraFilmbackSettings), LensSettings (FCameraLensSettings), FocusSettings (FCameraFocusSettings), CurrentFocalLength, CurrentAperture, CurrentFocusDistance and CurrentHorizontalFOV. Drive it through the setters (SetFilmback, SetLensSettings, SetFocusSettings, void SetCurrentFocalLength(float InFocalLength), void SetCurrentAperture(const float NewCurrentAperture)) so derived values recompute. ACineCameraActor adds LookatTrackingSettings (FCameraLookatTrackingSettings). ACameraRig_Rail exposes CurrentPositionOnRail (0–1 along its spline) and bLockOrientationToRail; ACameraRig_Crane exposes CranePitch, CraneYaw, CraneArmLength, bLockMountPitch and bLockMountYaw. Attach a camera actor to either and animate the exposed floats. Sequencer ownership: camera cuts, spawnables, ULevelSequencePlayer and take recording belong to ue-sequencer-cinematics. This skill covers the camera objects themselves.