CamForge
Data-driven third & first person camera manager

Overview

CamForge is a camera manager for Unreal Engine 4.27 and 5.8. It replaces the view your player sees with a complete camera rig computed every frame — no spring arm and no camera component on the pawn are needed. Camera values live in a CamForge Settings data asset and are chosen by the state of the view target; when the state changes, the camera blends to the new values.

• Settings by view mode (third / first person), rotation mode (velocity direction, looking direction, aiming), stance (standing, crouching) and gait (walking, running, sprinting), plus named action state overrides such as Rolling or Mantling.
• Smooth blends with a blend time per settings set and an optional easing curve.
• Arm length, camera offset, pivot offset, per-axis pivot lag, rotation lag, field of view and pitch / yaw / roll limits per set.
• Camera collision with instant pull-in and smooth recovery; the view target and its attachments are ignored.
• First person at a mesh socket or eye height, with blended transitions to and from third person.
• Shoulder swap, target lock-on, occlusion fade, speed-based FOV and smooth zoom.
• Zero-code support for any pawn through the CamForge Target component, full control through the CamForge Target Interface.
• Built-in defaults in C++: the plugin ships no content and works without a settings asset.

Requirements

Installation

1. Install CamForge from Fab into your engine, or copy the CamForge folder into your project's Plugins folder.
2. For a C++ project, regenerate project files and build the editor target.
3. Open the project, enable CamForge in Edit > Plugins and restart the editor.
4. C++ only: add PublicDependencyModuleNames.Add("CamForge"); to your Build.cs.

Quick start

Blueprint

1. Open your Player Controller Blueprint (the one set in your Game Mode). In Class Defaults set Player Camera Manager Class to CamForge Player Camera Manager.
2. Open your pawn or character Blueprint and add the CamForge Target component. Nothing else is required: stance follows the character's crouch state and gait follows its speed.
3. Make sure the pawn receives look input (Add Controller Yaw Input / Add Controller Pitch Input, as in the engine templates) — CamForge follows the controller's control rotation.
4. Press Play. You get an over-the-shoulder third person camera with collision, lag and speed-based FOV. Existing camera and spring arm components on the pawn are ignored while CamForge is enabled.
5. Bind input on the player controller or pawn, using Get CamForge Camera Manager:
   • Mouse wheel / gamepad axis → Add Zoom Input (positive zooms in)
   • Shoulder key → Swap Shoulder
   • View key → Toggle View Mode
   • Aim pressed / released → Set Rotation Mode (Aiming / Looking Direction)
   • Lock-on key → Find Best Lock On Target (with your enemy list) then Lock On To, or Clear Lock On
6. To tune the camera: Add > Miscellaneous > Data Asset, pick CamForge Settings. Create a Blueprint child of CamForge Player Camera Manager, set its CamForge Settings to the asset and use that Blueprint as the Player Camera Manager Class (or call Set CamForge Settings at runtime). A new asset starts with the built-in defaults.

C++

// Build.cs: PublicDependencyModuleNames.Add("CamForge");
#include "CamForgePlayerCameraManager.h"
#include "CamForgeTargetComponent.h"
#include "CamForgeLibrary.h"

AMyPlayerController::AMyPlayerController()
{
    PlayerCameraManagerClass = ACamForgePlayerCameraManager::StaticClass();
}

AMyCharacter::AMyCharacter()
{
    CameraTarget = CreateDefaultSubobject<UCamForgeTargetComponent>(TEXT("CameraTarget"));
}

void AMyCharacter::OnZoom(float Value)
{
    if (ACamForgePlayerCameraManager* Camera = UCamForgeLibrary::GetCamForgeCameraManager(this, 0))
    {
        Camera->AddZoomInput(Value);
    }
}

void AMyCharacter::OnAim(bool bAiming)
{
    CameraTarget->SetRotationMode(bAiming ? ECamForgeRotationMode::Aiming : ECamForgeRotationMode::LookingDirection);
}

How a frame is computed

For the main view target, every frame the camera manager:

1. Reads the camera state (interface → component → Default Camera State) and fires events when it changed.
2. Resolves the settings set for that state and, when the set changed, starts a blend from the current values over the new set's Blend Time, eased by its Blend Curve (smooth step when empty).
3. Takes the controller's control rotation and applies Rotation Lag Speed.
4. Builds the pivot: pivot target transform + Pivot Offset (in the pivot's local space), moved toward a locked target for framing, then lagged per axis in camera-yaw space with Pivot Lag Speed. A jump larger than Teleport Distance skips the lag.
5. Places the third person camera: Arm Length (with zoom and lock-on extra) behind the pivot along the view direction plus Camera Offset in view space, the Y offset mirrored by the shoulder side; sweeps for collision and finds occluders.
6. Places the first person camera at the first person target plus Camera Offset.
7. Blends third and first person locations while the view mode changes, writes location, rotation and field of view (plus the speed FOV kick) and applies the set's view rotation limits to the controller.

Camera state

FCamForgeCameraState selects the settings. It comes from the view target's interface when implemented, else its component, else the manager's Default Camera State (with automatic stance and gait when Auto Stance For Default State / Auto Gait For Default State are on).

Settings asset

UCamForgeSettings is a data asset (Add > Miscellaneous > Data Asset > CamForge Settings). Assign it to CamForge Settings on the camera manager; without an asset the class defaults are used.

How the set is chosen

Built-in rules (in order): Aiming Crouched, Aiming, Crouching, Sprinting, Running, Looking Direction. Built-in action states: Rolling, Mantling. Resolve Camera Settings and Resolve Settings Name preview what a state resolves to.

Camera settings set (FCamForgeCameraSettings)

Other sections of the asset

Target component

Add CamForge Target (UCamForgeTargetComponent) to any pawn for zero-code support. It does not tick; the camera manager reads it every frame.

Target interface

Implement CamForge Target Interface (ICamForgeTarget) on the view target to drive the camera yourself. Every function is a Blueprint Native Event returning true when it provided a value; return false (or leave it unimplemented) to fall back to the component, then to the defaults.

// C++ implementation on a character
UCLASS()
class AMyCharacter : public ACharacter, public ICamForgeTarget
{
    GENERATED_BODY()
public:
    virtual bool GetCameraState_Implementation(FCamForgeCameraState& OutState) override
    {
        OutState.RotationMode = bAiming ? ECamForgeRotationMode::Aiming : ECamForgeRotationMode::LookingDirection;
        OutState.Stance = bIsCrouched ? ECamForgeStance::Crouching : ECamForgeStance::Standing;
        OutState.ActionState = bRolling ? FName(TEXT("Rolling")) : NAME_None;
        return true;
    }
};

Camera manager nodes

ACamForgePlayerCameraManager (Blueprintable). Properties: CamForge Settings, CamForge Enabled, Default Camera State, Auto Stance / Auto Gait For Default State.

Events

Bind them on the camera manager (for example in your Player Controller after Begin Play with Get CamForge Camera Manager From Controller). State events fire for the main view target, not on the first frame after a view target change.

Collision

A sphere sweep from the trace origin (default: the unlagged pivot) to the desired camera location pulls the camera in front of blocking geometry instantly and eases it back out at Recover Speed. The view target, actors attached to it and its attach parent are ignored.

The interface (Get Camera Trace Params) or the component (Override Trace Params) can replace origin, radius and channel per view target.

First person

In first person the camera sits at the first person target: the interface value, else the component's First Person Socket Name on the skeletal mesh (default head) plus offset, else the pawn's eye height. The First Person set provides FOV, limits and offsets; its Arm Length pulls the camera back from the eyes (with a collision sweep when above 0). Switching view mode blends position, FOV and limits over the destination set's blend time.

Shoulder swap

The third person Camera Offset Y is multiplied by the shoulder value: Right = +1, Center = 0, Left = −1, blended at Switch Speed. Swap Shoulder toggles Left / Right (from Center it goes to the side opposite the last one used); Set Shoulder picks a side; On Shoulder Changed reports it.

Target lock-on

Lock On To locks onto an actor (fails when it is invalid, the view target itself, or out of range). While locked, the control rotation is steered softly toward the target, the pivot moves part of the way toward it so both stay in frame, and the arm grows with the distance. The lock ends on Clear Lock On, when the target is destroyed, farther than Max Distance, or hidden longer than Lost Sight Time. Find Best Lock On Target picks the candidate closest to the view direction within an angle and the range.

Occlusion fade

Primitives that block the Occlusion Channel between the trace origin and the camera are faded and restored when they no longer occlude. The view target, its attachments and the locked target are never faded; pawns are skipped by default.

Dynamic FOV

Adds field of view as the view target moves faster, smoothed. Without a curve the kick rises linearly from 0 at Min Speed to Max FOV Add at Max Speed.

Smooth zoom

Add Zoom Input changes the arm length of the current view mode by Step Per Input per unit (positive input zooms in) and interpolates toward it. While zoom is enabled for a view mode, the final arm length stays between its Min Arm Length and Max Arm Length. The zoom is kept per view mode across state changes; Reset Zoom returns to the settings' arm length.

Function library

Debugging

Console variable CamForge.Debug (development builds):

Types

Networking

CamForge is not replicated. A camera manager exists only for local players and computes the view on that machine; the component's state is local as well. In multiplayer, drive the camera state from replicated gameplay state on each client (for example set the rotation mode from your replicated aiming flag, or implement the interface on top of replicated variables). Lock-on steers the local control rotation, which the engine sends to the server like any other look input.

Troubleshooting

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Built and verified for Unreal Engine 4.27 and 5.8.