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:

[math] F = G \frac{m_1 m_2}{r^2}[/math]

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 [math]r1[/math], [math]r2[/math] and [math]r3[/math], the gravitational force on each mass can be expressed as:

[math]\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)[/math],

[math]\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)[/math],

[math]\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)[/math]

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

[math]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[/math]

To solve these equations analytically, we would need to find explicit functions [math]r1(t)[/math], [math]r2(t)[/math], and [math]r3(t)[/math] 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

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

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

My Engine in OPENGL

Im working on a OPENGL project for better understanding rendering and shaders

My main focus is to learn HLSL correlated with c++ and all the libraries for optimize my own 3D game made by scratch.

For now there is a pyramid manually generated and a light cube (also manually generated).