Gameplay Ability System + Motion Matching

Gameplay Ability System (GAS) + Motion Matching

One of the best plugins for unreal engine combines a huge varety of progressive animations that blend each other smoothly, in order to give a fluid movement in-game. But how this happens in real work environment?

To demonstrate it’s potential I combined a Motion matching system in Unreal 5.4 with Gameply Ability System and created a sets of Abilities that blends witht the Motion Matching

 

What I used for this project?

Unreal Engine 5.4; Motion Mathing 5.4 version; Gameplay Ability System (GAS); Blueprints & C++ for an hybrid approach.

Implementation

First of all, I implemented the GAS plugin, since it requires a bit of setup. You can find all the material in the Unreal official documentation

After that I imported the Mannequin Blueprint (with every other mesh, bp and animations sequences) in my project starting from a new one

Disclamer: in this project I used 5.4 version since the 5.5 was not on the market yet, so all the IK rig is implemented by myself; an upgrade to the new version will result in smoother animations (since there ar

e hundreds more for each case) but is suggested to start a project from scratch rather than update this one since the amout of complexity and changes from the previous verison.

Other than a simple trigger for abilities I spent some time to implement some Base Attributes for the character, because is more engaging to see the stats of your player, doesn’t it? This are Health (in red), Stamina (in green) and Energy (in Yellow). Stamina is for sprinting and Energy is for abilities, and all of three restores after some time.

How to shoot a rock

The idea is simple: the character crouches on the bottom in search of a rock, it grabs it and throws it to the enemy. Nothing unusual, but lets add a complication: I wanted the player to be able to move while doing that, avoiding attack from the enemies while doing that. Is not pleasing to receive all the attacks while you are doing a simple crouching, isn’t it?

I used the animation Blueprint to split the body in 2 parts, one above the pelvis where the animation should be player and one under the pelvis, where the motion matching will continue undisturbed.

Here is how I implemented iside the Animation Blueprint if you are curious

Note: I used Inertialization for this, otherwise the animation won’t work correctly:

After splitting the body in 2 parts now I needed to force the upper part to crouch a bit more since I wanted to give the idea of the player picking up something from the ground. I simply created a trigger in the animation blueprint which changes a variable called DoCrouch at the right moment.

And now after all of this I coould Implement an animation in the Ability, and this is the result:

How to unlock the Matrix

Let’s say is pretty cool to have for our character an ability to stop bullets in mid air, but how to implement?

First let’s this about our main implementation, once the ability is activated we could spawn an invisible wall in front of the player, attach it to his hand and from that moment detect every projectile collision and stop them.

Straightforward: what about the animation?

We can use the same technique as before and split the body in 2 parts: the one that we want animate and the one we dont want.

This animation is pretty straightwarward so I did by miself using only the unreal Sequencer

Now after that let’s split the bone from the upperarm_r bone

This is the result:

I added also some warping animation, because is more cool to see.

 

How to punch

This is the most straightforward ability, and does not require further Motion matching Implementation but is a set of combo inside Gameplay Ability System: the approach I used was with Gameplay Tags, carefully assiged to the player in specific framw window where you can re-trigger the ability and move to the next one with the same trigger button, in my case the left-mouse.

If you are curious about it I left for you the implementation for the first punch, the other ones are pretty straight-forward, and they just need to change some parameters in the class defaults in order to block further unwanted abilities

 

That’s all folks. Hope you enjoyed my explaination on this topic and invite you to try by yourself, once understood the process is just settings and pretty straightforward with a medium-hight complexity.

View Project

Solving the Three Body Problem in Unreal Engine

The Three Body Problem Solved in Unreal Engine 5

The three-body problem is one of those rare physics problems that drastically changed our understanding of the universe as we know it, to the point that is still unsolvable nowadays, and today with the programming skills that I have and Unreal Engine I want to showcase to you how I solved this problem.

Introduction to the problem

Let’s start by stating the problem:

Suppose we have three corpses or “bodies” with mass, all affected by the gravitational pool of the other, and suppose we know their initial positions and momentum, predict the bodies’ future position and momentum at the same time.

Now, if you remember some basic physics principles learned in high school you know Newton’s law of Universal Gravitation:

$F = G \frac{m_1 m_2}{r^2}$

But Newton didn’t taught initially to apply his law to three bodies, only after discovering the formula he applied to a more general solution and catatrophy happened.

Lets’ try to do what he did many centuries ago:

Each mass exerts a gravitational force on the others. For three bodies located at positions $r1$, $r2$ and $r3$, the gravitational force on each mass can be expressed as:

$\mathbf{F}_1 = G \frac{m_1 m_2}{|\mathbf{r}_2 – \mathbf{r}_1|^3} (\mathbf{r}_2 – \mathbf{r}_1) + G \frac{m_1 m_3}{|\mathbf{r}_3 – \mathbf{r}_1|^3} (\mathbf{r}_3 – \mathbf{r}_1)$,

$\mathbf{F}_2 = G \frac{m_2 m_1}{|\mathbf{r}_1 – \mathbf{r}_2|^3} (\mathbf{r}_1 – \mathbf{r}_2) + G \frac{m_2 m_3}{|\mathbf{r}_3 – \mathbf{r}_2|^3} (\mathbf{r}_3 – \mathbf{r}_2)$,

$\mathbf{F}_3 = G \frac{m_3 m_1}{|\mathbf{r}_1 – \mathbf{r}_3|^3} (\mathbf{r}_1 – \mathbf{r}_3) + G \frac{m_3 m_2}{|\mathbf{r}_2 – \mathbf{r}_3|^3} (\mathbf{r}_2 – \mathbf{r}_3)$

From Newton’s second law, the equations of motion for each mass are:

$m_1 \frac{d^2 \mathbf{r}_1}{dt^2} = \mathbf{F}_1, \quad m_2 \frac{d^2 \mathbf{r}_2}{dt^2} = \mathbf{F}_2, \quad m_3 \frac{d^2 \mathbf{r}_3}{dt^2} = \mathbf{F}_3$

To solve these equations analytically, we would need to find explicit functions $r1(t)$, $r2(t)$, and $r3(t)$ that describe the positions of the bodies as functions of time. However, we can’t obtain an analytical solution due to the nonlinear and coupled nature of these differential equations.

Ok but what does it mean?

It means that having a system where three or more bodies move them attracted by gravity is unpredictable and chaotic, which tells us that the equation’s solution is impossible!

We can’t describe with absolute precision the motion of more bodies that interact with each other by gravity, and even if we found one the smallest change on the initial conditions of one of the bides can collapse everything we did before.

This means, for example, that the solar system is not as stable and predictable as we think after all.

Bonus: The approach of Henri Poincaré

Poincaré, instead of solving the equation tried to analyze the system’s behavior, introducing the concept of phase space: a geometric representation of the space that allowed him to visualize the possible states (stable or not stable) of a system. Here, each possible configuration of the bodies’ positions and velocities corresponds to a unique point.

Through this approach, he discovered that the three-body problem exhibits sensitivity to initial conditions: small differences in the starting positions or velocities of the bodies grow rapidly over time, leading to vastly different trajectories. With Poincaré Chaos Theory has born, revealing that even simple systems governed by deterministic laws could behave unpredictably.

Moreover, he found that the system’s paths in phase space could form beautiful and intricate patterns, which he called homoclinic tangles. These patterns, where trajectories repeatedly approach and diverge from one another in complex, non-repeating ways, showed that the system could exhibit chaotic, non-periodic motion instead of settling into a predictable cycle.

So if the problem is unpredictable and still unsolvable how do you solve it?

Well, is true that we can’t solve the Three-body problems with a neat mathematical formula that works for every scenario (the general solution we were talking about), but this doesn’t mean that we can predict the motion of the corpses with a very good approximation. And with the technologies and the large amount of computer calculations we can use it for good.

The Special Solution of Three-Body Problem

For Special we mean that we are examining a particular case of the problem.

We can’t calculate the position of three bodies simultaneously, but this is not true for just two of the bodies in consideration.

Using the gravitational laws of Newton we will calculate the position of two of the three bodied and move them by an instant (in Unreal we use Tick) and we do the same for the other combinations of the bodies in the scene. This method is called the Euler’s Method.

Enough math, let’s see some code:

I created the Body class, which contains all the information about the corpse:

And in the Gamemode I created a special function called CalculateGravitationalForces(), which apply the forces to each pair of body every Tick:

Finally, lets move the pair of bodies:

And put these objects in the game. Here I added to them a glow material to resemble little suns and a Particle Trail to trace their path when they move

And here we go: Three Bodies moving in the environment of Unreal Engine!

Notice how each time at runtime we have different paths

View Project

Advanced Outline Shader in Unreal Engine 5

Welcome to the showcase of my highly versatile Outline Shader Post-Process in Unreal Engine. This shader is designed to provide a sleek and customizable outlining effect to enhance the game’s visual aesthetics

This project is inspired by Evans Bohl video on Advanced outline Shaders, and broke down his core steps to a more refined way

Key Features

• 1. Customizable Outline Size

  • Adjustable Thickness: Easily control the thickness of the outline to suit different art styles and visual requirements. Whether you need a subtle edge or a bold highlight, our shader provides precise control over the outline size.
  • Dynamic Scaling: Outline thickness can dynamically scale based on distance, ensuring consistent visual quality at all zoom levels.

• 2. Selectable Elements

  • Per-Element Outlining: Choose which elements to outline in your scene. This includes meshes and characters. The shader gives you the flexibility to highlight only what’s important.
  • Layer-Based Selection: Use layers to manage and select groups of elements for outlining, simplifying the process of applying outlines to multiple objects.

  3. Color Customization

  • Hue Shift Node: To create dynamic color outlines, we implemented a hue shift node. By shifting the hue of a base red color (with a hue of zero), we can achieve a wide range of colors. A constant 3 vector with a red value of 1 is used as the base color input.
  • Emissive Factor: Control the shininess of the outlines by multiplying the base color with an emissive factor. This factor is promoted to a parameter called “Stencil Color Emissive Factor,” with a default value of 1. Adjust this value to make the outlines glow more or less, or even set it to 0 for black outlines.

  4. Overlapping Outline Management

  • Avoid Overlapping Outlines: Our shader includes advanced functions to prevent outlines from overlapping when different models are close together. This ensures clean and distinct edges for each object, maintaining visual clarity.
  • Edge Blending: Smooth transitions at intersecting outlines with our edge blending feature. This avoids harsh overlaps and creates a more cohesive visual experience.

 

How it works

An outline shader enhances the visual boundaries of objects in a scene, making them stand out by drawing lines around them. In Unreal Engine 5, this effect can be achieved using a combination of depth edge detection and normal edge detection.

Depth Edge Detection identifies edges based on the differences in depth values between adjacent pixels. Depth values indicate the distance from the camera to the object surface, so edges are detected where there are significant changes in depth.

• Depth Buffer:
  • A depth buffer stores the depth information for each pixel in the scene.
  • When rendering, the depth of each pixel is compared to detect significant changes.
• Edge Detection Process:
  • The shader compares the depth values of neighboring pixels.
  • If the difference exceeds a certain threshold, it marks an edge.

This works but some of the edges are located at places where depth does not vary a lot. That’s why we need to combine also Normal Edge Detection

Here is an example without Normal Edge Detection:

Normal Edge Detection identifies edges based on the differences in surface normals of adjacent pixels. Surface normals are vectors perpendicular to the surface, representing its orientation.

• Normal Buffer:
  • A normal buffer stores the normal information for each pixel.
  • Normals change direction where there are surface details or where different surfaces meet.
• Edge Detection Process:
  • The shader compares the normals of neighboring pixels.
  • If the angle between normals exceeds a certain threshold, it marks an edge.

Here is an example with Normal Edge Detection implemented:

 

Implementation Steps

• Convolution Kernel: Get the Current Pixel and its neighbors
• Detect Depth Edge and Normal Edge: Explained above
• Apply them to the Post Process Material which manages the main logic

Problems:

1. The Gazling Angle

With just these steps we can find that at the edges in parallel to the surface, some strange stuff happens: this is because the more angle of view is parallel to the surface, further the pixels of the same surface become from each other, which is interpreted as being part of an edge.

To avoid this problem I created a function which modulates the Depth Threshold based on the angle view:

This is the result after implemented in the Material:

2. Camera Far Away

What happens when the player sees an object really really far away? Initially, I didn’t set any rules so Unreal still shows the same thickness of the outline, causing in some cases to take up most space of the screen.

This is the point of view of the camera from very far away: you can clearly see the outline of the grass that covers completely the foliage and the sphere that shows the outline of the object that should not show.

To avoid this problem I implemented two solutions: One is called Thickness Modulation, which basically set a minimum and a maximum thickness based on the distance

This image shows the same distance with Thickness Modulation:

The other solution is Depth Masking, which basically shows the Outline of any object up to a specific distance

In this example, you can see exactly the moment when the outline is shown or hidden:

Extra Stuff

I implemented a Custom Depth Mask to select just specific models to draw the outline and a Custom Engine Tool to select specific colors and emissions for that specific object. Here below is a demonstration of this tool working perfectly:

 

If you want to donwload the project you can check my GitHub here

View Project