TrackForge
Physics-driven tracked vehicles, ready to drive

Overview

TrackForge is a set of C++ components built around a physics pawn whose code runs on every physics step. The ready-to-drive TrackForge Tracked Vehicle combines them; each part can also be used on its own in your own Blueprint vehicles.

• Ready-to-drive tracked vehicle with a physics chassis, two tracks of five road-wheels each and throttle / steering input with differential steering.
• Engine with a torque curve (your Curve Float or the built-in curve), idle and rev limiter, engine braking and an RPM output.
• Gearbox in automatic or manual mode with any number of forward gears, reverse, final drive, efficiency and shift time.
• Service brakes and parking brakes per track.
• Neutral steer: the tracks counter-rotate to pivot on the spot when the vehicle is stationary.
• Surface friction data asset: friction scale and rolling resistance per physical surface.
• Track tension: the upper run of the track sags when the tension is lowered.
• Track speed per side and automatic material UV scrolling on given material instances.
• Road-wheel sync: wheel meshes spin with the track and follow the suspension.
• Telemetry: speed, RPM, torque, gear, track speeds, slip and grounded wheels in one struct.
• Anti-roll stabiliser between left and right suspension.
• Cruise control and speed limiter driven by the PID controller.
• Turret / aim rig with yaw and pitch speeds and angle limits, aiming at a target, by input or by angles.
• Server-authoritative networking: input is sent to the server, the server runs the physics and the movement replicates.
• TrackForge.Debug console variable drawing suspension rays, contact and friction forces and telemetry text.
• Building blocks: physics sub-step pawn, suspension stacks (ray, sphere or shape sweep), friction component with friction ellipse, PID controller, track animation along a spline and sub-stepping-safe Blueprint nodes.

Requirements

Installation

1. Install TrackForge from Fab into your engine, or copy the TrackForge folder into your project's Plugins folder.
2. Enable TrackForge in Edit > Plugins and restart the editor.
3. C++ only: add PublicDependencyModuleNames.Add("TrackForge"); to your Build.cs.

Quick start

1. Create a Blueprint class from TrackForge Tracked Vehicle (ATrackForgeVehiclePawn).
2. Assign your hull mesh to ChassisMesh and resize the Chassis box (default extent 300 x 150 x 60 cm, mass 20000 kg) to cover the hull.
3. In the Event Graph, call Set Throttle Input and Set Steering Input from your input events (W/S and A/D, a gamepad stick or Enhanced Input actions). Alternatively set Throttle Axis Name and Steering Axis Name to legacy axis mappings.
4. Place the vehicle above the ground, set Auto Possess Player to Player 0 and press Play. Type TrackForge.Debug 1 in the console to see the suspension and telemetry.
5. Optional: add a TrackForge Track Animation per side for treads, a TrackForge Wheel Sync for road-wheel meshes and a TrackForge Turret for the turret.

Tracked vehicle

Pawn ATrackForgeVehiclePawn — displayed as TrackForge Tracked Vehicle; derives from the TrackForge Physics Pawn.

Every physics step the vehicle reads the input, applies cruise control and the speed limiter, updates the gearbox and engine speed, computes the drive and brake force of each track, updates the suspension of both tracks, applies the anti-roll forces and finally solves the track-to-ground friction and the new track speeds.

Driving input

Input values are clamped and invalid numbers are ignored. The setters work for players, AI controllers and for unpossessed vehicles on the server (for example driven by the Level Blueprint).

Engine

struct FTrackForgeEngineSettings (Engine Settings).

In gear the engine speed follows the sprockets: RPM = average sprocket speed × total ratio × 60 / 2π (never below idle). Each track receives half of torque × total ratio × efficiency / sprocket radius. pure Get Engine RPM and pure Get Engine Torque At RPM (RPM) read the engine.

Gearbox

struct FTrackForgeGearboxSettings (Gearbox Settings). Gears are numbered -1 (reverse), 0 (neutral) and 1..N (forward).

Automatic: positive throttle engages first gear, the gearbox shifts up at the upshift point while accelerating and down at the downshift point. Holding negative throttle brakes the vehicle and, once it is nearly stopped, engages reverse; negative throttle then drives backward. Manual: select gears with Shift Up, Shift Down or Set Gear (Gear); positive throttle drives in the direction of the gear and negative throttle brakes.

Brakes

struct FTrackForgeBrakeSettings (Brake Settings).

The service brake slows the track itself (it never reverses it); the ground friction then slows the vehicle. A parking brake locks its track: the track speed stays zero and the track acts as part of the chassis, so the friction holds the vehicle on slopes.

Steering & neutral steer

struct FTrackForgeSteeringSettings (Steering Settings).

During a neutral steer the left track drives at +steering and the right track at -steering; the automatic gearbox engages first gear for it. In manual mode a neutral steer needs a gear selected.

Cruise control & speed limiter

Both use the vehicle's SpeedController (TrackForge PID Controller) on the error in km/h. struct FTrackForgeSpeedControlSettings (Speed Control Settings):

TrackForge PID Controller

Component UTrackForgePIDController: Num Of Errors To Store (5, minimum 3), Proportional Coefficient (0.1), Integral Coefficient (0), Derivative Coefficient (0.05). Nodes: Add Measured Error (FTrackForgePIDErrorItem: Measured Value, Delta Time), Get Control Coefficient (0 until three errors are stored), Reset Controller, Get Num Stored Errors. The integral term sums the stored errors times their delta time; the derivative term uses the last two errors.

Tracks & friction

Component UTrackForgeTrackComponent — displayed as TrackForge Track. A row of suspension stacks plus the track's own speed. Its X axis points forward along the track.

Friction is Coulomb friction with a stopping force: at each contact the force that would cancel the relative velocity of the track surface against the ground is clamped by normal force × mu static, or by the kinetic limit once exceeded. With anisotropic friction the coefficients come from the friction ellipse. Along the track the chassis and the moving track are solved together (reduced mass), so the engine force reaches the chassis without overshoot; the reaction slows the track.

TrackForge Friction (standalone)

Component UTrackForgeFrictionComponent processes contacts you register yourself (collision hits or suspension contacts): Register Friction Point, Physics Update (returns the normalized reaction force and rolling friction force), Set Friction Surface Velocity / Set Friction Surface Speed, Reset Friction Points, Is Friction Point Active, Get Friction Force, Get Friction Limit, Set Effected Component Reference, Toggle Debug Mode. Properties: Effected Component Name (none), Mu X Static 0.75, Mu X Kinetic 0.5, Use Anisotropic Friction false, Mu Y Static 1.0, Mu Y Kinetic 0.75, Physics Surface Response (rolling friction per surface), Surface Friction (asset), Is Alternate Friction (also counters gravity on slopes), Is Debug Mode.

TrackForge Vehicle Suspension

Component UTrackForgeVehicleSuspensionComponent updates several tracks of a custom vehicle with one Update Physics call. Tracks Configuration lists track components by name (empty = every TrackForge Track of the actor); Effected Component Name (Chassis) is passed to all of them. Get Tracks returns them.

Suspension & anti-roll

Object UTrackForgeSuspensionStack with struct FTrackForgeSuspensionSettings. A stack traces from the spring top to the spring bottom offset, places the wheel hub at the contact and pushes the sprung component with spring and damper force.

Stack nodes: Physics Update, Initialize, Get Suspension Force, Get Contact Data, Get Wheel Hub Position, Get Wheel Hub Transform, Set Sprung Component Reference, Set Sweep Shape Component Reference, Set Spring Stiffness, Set Spring Offsets, Set / Get Suspension Force Scale (active suspension), Get Suspension Compression Ratio (0 extended, 1 compressed), Apply Anti Roll Force, Is In Contact, Get Last Trace Segment, Toggle Debug Mode. The TrackForge Suspension Stack component (UTrackForgeSuspensionStackComponent) holds one stack at its own position.

Anti-roll stabiliser

After the suspension update the vehicle pairs the stacks of both tracks by index. For each pair touching the ground it applies Anti Roll Stiffness × (left compression - right compression) upward on the more compressed side and the same force downward on the other side, like an anti-roll bar. The extra load also feeds the friction of those wheels.

Surface friction asset

Data Asset UTrackForgeSurfaceFrictionAsset — create one with Add > Miscellaneous > Data Asset > TrackForge Surface Friction. Physical surfaces are defined in Project Settings > Physics > Physical Surface and assigned through physical materials.

Assign it to Surface Friction on a track (or a friction component): every friction coefficient is multiplied by the touched surface's scale (ice 0.15, mud 0.6, asphalt 1.1...), and rolling resistance is normal force × rolling coefficient.

Track animation

Component UTrackForgeTrackAnimationComponent — displayed as TrackForge Track Animation. Rotates sprocket, idler and road-wheel meshes, moves tread instances of an Instanced Static Mesh along a spline (in the XZ plane of the spline component), sags the upper run and scrolls track materials.

Road-wheel sync

Component UTrackForgeWheelSyncComponent — displayed as TrackForge Wheel Sync. Ticks after physics; spins road-wheel components by the speed of their track and moves them with the wheel hub of their suspension stack. Works on the tracked vehicle and on any actor with TrackForge Track components.

Nodes: Refresh Wheels (after editing Wheels at runtime), Update Wheels, Get Wheel Angle, Get Side Speed. The rest rotation and position of each wheel are kept; only the spin and the height change.

Turret

Component UTrackForgeTurretComponent — displayed as TrackForge Turret. The component itself is the yaw ring; attach your turret mesh to it and your gun mesh (or a gun pivot) below it, then name the gun in Gun Component Name.

Telemetry

pure Get Telemetry returns struct FTrackForgeTelemetry, updated every physics step:

Also: Get Track Speed (Side) in cm/s, Get Forward Speed Kmh, Get Track (Side) and the helpers TrackForge cm/s to km/h / TrackForge km/h to cm/s.

Networking

The tracked vehicle replicates and replicates its movement. The server is authoritative:

• The controlling client writes its input locally and sends it to the server with an unreliable Server RPC when it changes and every Input Resend Interval. The server clamps the values.
• The server runs the physics with that input, writes the drive train state (track speeds, RPM, gear) and replicates the input to the other clients (skip owner).
• With Clients Simulate Physics on (default), clients run the same physics with their input or the replicated input as a prediction, and the engine's replicated physics movement corrects them towards the server. With it off, clients stop simulating the chassis and only follow the replicated movement; their telemetry, track speeds, RPM and gear come from the server.
• The turret component replicates too: the controlling client predicts its turret and sends its aim request; the server's angles replicate to the other clients.

pure Is Simulating Locally tells whether this machine runs the physics. Settings changed at runtime (speed limit, tuning) are not replicated: change them on the server.

Debugging

Console variable TrackForge.Debug 1 draws, for every TrackForge Tracked Vehicle, the suspension rays (green hit, yellow miss), contact points, hub positions, suspension force (blue) and friction force (orange) arrows, plus a telemetry text above the vehicle (speed, gear, RPM, torque, track speeds, slip, grounded wheels and active modes). It does nothing in shipping builds. Each stack also has its own Enable Debug Mode, and the friction and animation components have Is Debug Mode / Debug Mode.

Physics pawn & library

Pawn ATrackForgePawn — displayed as TrackForge Physics Pawn. Its root must be a primitive component that simulates physics.

Function Library UTrackForgeLibrary — sub-stepping friendly nodes that work on the physics body directly:

C++

#include "TrackForgeVehiclePawn.h"
#include "TrackForgeTurretComponent.h"

void AMyTank::SetupPlayerInputComponent(UInputComponent* Input)
{
    Super::SetupPlayerInputComponent(Input);
    Input->BindAxis("MoveForward", this, &AMyTank::SetThrottleInput);
    Input->BindAxis("MoveRight", this, &AMyTank::SetSteeringInput);
}

void AMyTank::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

    const FTrackForgeTelemetry Data = GetTelemetry();
    EngineAudio->SetFloatParameter("RPM", Data.EngineRPM);

    if (UTrackForgeTurretComponent* Turret = FindComponentByClass<UTrackForgeTurretComponent>())
    {
        Turret->SetAimTarget(GetAimPoint());
    }
}

// Highway mode
SetCruiseControl(true, 35.0f);
SetSpeedLimit(50.0f);

Override SimulatePhysicsStep(float) in a ATrackForgePawn subclass to run your own code on every physics step. FTrackForgeFrictionMath (Solve, GetMuFromFrictionEllipse) exposes the friction solver to C++.

Troubleshooting

Credits

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