Async-Physics-Suspension-Kinematics

KO | EN

gitlite — search

#python #hacktoberfest #llm #go #golang #rust #deep-learning #linux #java #awesome #cli #security #ios #mcp

Async-Physics-Suspension-Kinematics

(★ 41)

Highly configurable MacPherson & double wishbone suspension kinematics for UE5/Chaos, with runtime tuning thanks to the GT↔PT architecture.

Async-Physics-Suspension-Kinematics 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# UE5 Vehicle Suspension — MacPherson and Double Wishbone

![Unreal Engine](https://img.shields.io/badge/Unreal%20Engine-%23313131.svg?logo=unrealengine&logoColor=white) [![Watch on YouTube](https://img.shields.io/badge/Watch%20on-YouTube-red?logo=youtube)](https://youtu.be/hTsamMiJ834)

GripRush is a UE5 plugin focused on the accurate simulation of **MacPherson** and **Double Wishbone** suspension systems.

Rather than treating suspension travel as a simple vertical spring motion, GripRush aims to reproduce the **actual planar kinematics** of these mechanisms. Their geometry is solved from linkage constraints using a **circle-intersection method**, then reconstructed into world-space wheel frames and hub positions.

![Sample Project Screen](https://raw.githubusercontent.com/fgrenoville/Async-Physics-Suspension-Kinematics/main/Images/SampleProjectScreen.png "Sample Project Screen")

The result is a system built to capture not only force response, but also the mechanical logic that defines how these suspension layouts truly move — making wheel motion more credible, and the overall simulation more immersive and engaging.

GripRush also builds on and extends an async simulation pattern previously explored [here](https://github.com/fgrenoville/Async-Physics-Suspension-MT)

By leveraging **Chaos asynchronous physics simulation** through a **thread-safe** data flow, the plugin allows suspension parameters to be adjusted at runtime with an immediate effect on the vehicle’s behavior.

## What the plugin actually simulates

GripRush currently models a **single rigid chassis** receiving suspension forces from four corners.

At every physics step, each corner:

1. resolves its kinematic state,
2. builds a wheel frame,
3. queries ground contact,
4. computes spring and damper force,
5. applies the resulting force back to the chassis rigid body.

This is **not** a full vehicle gameplay framework.  
It is a focused **suspension and steering foundation** for teams who want to build their own handling stack on top of a clean async architecture.

## Feature overview

### Async simulation architecture

Built around **Chaos callbacks** and a strict separation between **Game Thread** and **Physics Thread** responsibilities.
The Game Thread prepares simulation snapshots and consumes outputs for visuals, telemetry, and debug tooling, while the Physics Thread runs the actual suspension simulation.
This keeps the data flow explicit, helps preserve thread safety, and allows runtime parameter changes to affect vehicle behavior immediately.

### Multiple suspension models

- **Simple**  
  Treats the suspension as motion along a single strut axis. It is lightweight, stable, and intended for projects that explicitly target a more **arcade-style** handling model, where a full kinematic suspension solution would add complexity without delivering a proportional gameplay benefit.

- **MacPherson**  
  Reconstructs the mechanism from its planar constraints, using the control arm, upper mount, and strut geometry to solve ball joint position, steering axis, hub location, and wheel frame. The resulting configuration is then fed into the shared wheel-contact and force computation pipeline.

- **Double Wishbone**  
  Solves the upper and lower linkage geometry in the suspension plane, rebuilds the knuckle configuration, and derives hub position and wheel frame from it. That configuration then flows through the same shared contact and spring-damper path, while preserving the more articulated behavior of a double wishbone layout.

### Steering

Support for **parallel steering** and **Ackermann steering**, allowing the steering behavior to be adapted to different vehicle goals and handling styles.

With **parallel steering**, both front wheels are driven by the same steering angle. This provides a simpler and more direct response, which can be appropriate when physical steering geometry is not the main priority.

With **Ackermann steering**, inner and outer wheel angles are solved separately so that the front axle follows a more mechanically coherent steering pattern during turns.

The steering model is configurable through parameters such as maximum steering angle, steering rate, and return-to-center speed, making it possible to shape the response both for more realistic setups and for more gameplay-oriented driving behavior.

### Wheel-ground contact models

- **Simple line trace**  
  A single lightweight trace from the wheel hub toward the ground.

- **Box-sweep arc sampling**  
  Multiple spoke-like box sweeps distributed over an arc. This is more expensive, but usually produces cleaner and more believable results over curbs and rough terrain. The final hit is selected using radial consistency criteria rather than a simple “first hit wins” rule, making contact reconstruction more robust.

### Force model

After a valid wheel contact has been found and the suspension state has been resolved, GripRush computes suspension force through a shared force pipeline common to all supported suspension models.

The model combines spring stiffness, preload, and a damping response split between **bump** and **rebound**, with separate low-speed and high-speed regions. A configurable threshold controls the transition between those damping regimes, while force clamping is used as a final safeguard against excessive spikes.

The computed force is then projected into world space and applied to the chassis at a configurable point.

By using the same force path across different suspension layouts, GripRush preserves a coherent force response while still allowing each model to retain its own kinematic behavior.

### Visual pipeline

The results computed during the physics step are also used to reconstruct the visual motion of the suspension assembly, not just its force response.

GripRush drives the placement and orientation of the main mechanical elements at each corner, including the wheel mesh, knuckle, brake disc and caliper, tie rod, half shaft, control arms, and shock components such as spring, piston, and end caps.

Rather than relying on rigged meshes or authored animations, these elements are animated procedurally in code from the state produced by the Physics Thread. This allows the visual suspension assembly to remain tightly aligned with the actual simulated kinematics.

To make integration more practical, each visual element supports editor-configurable positional and rotational offsets, helping adapt the system to existing vehicle meshes while minimizing asset-side adjustments.

### Runtime tuning API

GripRush exposes a runtime setup interface that can be accessed from both **Blueprint** and **C++**, allowing vehicle and suspension parameters to be read and updated while the simulation is running.

This makes the plugin well suited for workflows such as live setup screens, garage tuning menus, and in-game debug tools, where configuration changes need to be reflected immediately in vehicle behavior.

### Telemetry and debug streams

GripRush also includes telemetry and debug visualization tools that can be enabled through **CVars**.

These can be used to inspect suspension forces, kinematic states, wheel-ground contacts, and other runtime data that becomes especially valuable during setup, validation, and general development of the vehicle.

## How it works

### 1. Game Thread → Physics Thread snapshots

On `ScenePreTick`, GripRush collects the data required for the physics step and packs it into **PT-safe snapshot structs**.

That includes:

- driver input,
- steering configuration,
- per-corner suspension configuration,
- wheel query parameters,
- Chaos rigid body identifier (`UniqueIdx`).

No gameplay object is supposed to be dereferenced on the Physics Thread.  
The simulation consumes plain data only.

### 2. Persistent PT-side vehicle state

The Chaos callback keeps persistent per-vehicle state on the Physics Thread, including:

- steering state,
- per-corner suspension state,
- cached particle handles.

This allows GripRush to preserve continuity across steps without depending on UObject access.

### 3. Per-vehicle async simulation

Inside the Chaos callback, each vehicle is stepped independently:

- steering is integrated
- Ackermann is computed when enabled
- all four suspensions are solved
- suspension forces are applied to the chassis
- a per-step output snapshot is generated

The plugin can run this path:

- in **parallel** through `Chaos::PhysicsParallelFor`, or
- in **single-thread mode** for comparison and debugging

### 4. Physics Thread → Game Thread output

After the physics step, GripRush drains the generated output packets on `ScenePostTick` and uses them to:

- update component visuals
- refresh telemetry
- draw debug geometry
- print debug text

## Quick setup

1. Add the plugin to your UE5 project
2. Create a pawn based on `AGripRushVehicle`
3. Assign the chassis mesh
4. Configure the four suspension components:
   - suspension type
   - spring and damper settings
   - geometry
   - wheel dimensions
   - trace mode
5. Assign optional visual meshes
6. Bind your Enhanced Input actions and mapping context
7. Drop the vehicle into the level and start tuning

## Sample project

A sample project is also available [here](https://drive.google.com/file/d/1Au1p1iB_6kfwPq3RxQWuj5Q7Nt3gNVYz/view?usp=sharing)

It features a fully configured demonstration vehicle and an in-game setup menu that allows suspension parameters to be adjusted at runtime, making it possible to see their effect on the vehicle immediately.

The car reproduced in the sample is inspired by a **vintage Lotus Formula 1 car**, selected for its exposed and mechanically readable suspension layout. Both the **front** and **rear** suspensions are configured as **double wishbone**, making the project a particularly good fit for showcasing the plugin’s kinematic solver and procedural visual reconstruction.

Beyond serving as a visual demo, the sample is meant as a hands-on sandbox for tuning, inspection, and experimentation.

The sample project uses two additional plugins:

1. **Advanced UI Controls** — available for free here: [link](https://github.com/fgrenoville/Advanced-UI-Controls)  
2. **Motion Camera** — available on Fab here: [link](https://fab.com/s/bee87acf2a90)

`Motion Camera` is **not strictly required** for the sample project to work.  
If you do not have it, simply remove its references from the Blueprint. The project will still work, but you will lose the existing camera-switching logic and stabilization features.

### Controls

#### Driving
- `A / D` — Steer left / right

#### UI and camera
- `E` — Open / close the tuning panel
- `C` — Change view
- `X` — Toggle camera stabilization
- `Z` — Rear view

#### Mesh visibility
- `R` — Toggle shock mesh visibility
- `T` — Toggle wheel mesh visibility
- `Y` — Toggle knuckle mesh visibility
- `U` — Toggle brake disc mesh visibility
- `I` — Toggle brake caliper mesh visibility
- `O` — Toggle upper / lower control arms visibility
- `P` — Toggle tie rod visibility
- `L` — Toggle half shaft visibility

### Disclaimer

The 3D model used in the sample project is sourced for free from third-party platforms such as [Sketchfab](https://sketchfab.com/3d-models/formula-1-lotus-49c-d08e707e8d4442469f3bfacd5d5d3441)  
Credit: **dark_igorek**

This model is included solely for educational, research, and reference purposes. All rights remain with the original automotive manufacturers, design owners, and other respective rightsholders.
If you are a rightsholder and believe that any content included in this sample project should not be distributed, please contact me and I will promptly review the request and remove the relevant material if necessary.

## Known limitations / current caveats

A few things are worth stating clearly:

- **Wheel contact currently relies on a world reference passed into the Physics Thread for traces.**  
  It works as a practical compromise, but a future version should move toward fully Chaos-native scene queries.

- **Wheel spin is currently visualized using a constant angular speed placeholder.**  
  This is mainly intended to verify that wheel-related rotations are behaving correctly and to visually validate linked parts such as half shafts.  
  If you do not want the wheels to spin visually, comment out this line in `UGripRushSuspensionComponent::UpdatePostPhysicsVisuals`:
  `const float OmegaRad = 20.0f;`

- **Suspension kinematics may fail to produce a valid solution for some parameter combinations.**  
  This is not a solver bug. In many cases it is simply the result of an inconsistent geometric setup: just as in a real mechanism, some suspension configurations cannot physically “close” for the requested state. When that happens, the solver exits early, the suspension is not simulated for that step, and `EGripRushSuspensionDiagnostic` enum is set with the corresponding error flag.
  
- **The valid suspension travel range is currently estimated by iterating over spring compression length.**  
  This works, but it is not performant and should eventually be replaced with a more advanced method.

## Acknowledgements

This plugin would not exist without the precious help of **Ivan Novozhilov** and the wonderful people in the **Vehicle Physics** Discord community.  
Thank you.

## Contributing

❤️ Enjoying it? Leave a star on the repo.

Feel free to fork it, experiment with it, and share what you build — seeing it used in real projects would be the best outcome for this work.

If you find a bug, have a suggestion, or want to improve the plugin, open an issue or submit a contribution.

Async-Physics-Suspension-Kinematics

Async-Physics-Suspension-Kinematics 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Async-Physics-Suspension-Kinematics

Async-Physics-Suspension-Kinematics 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README