Jose Moreno Profile picture
Oct 24, 2022 17 tweets 8 min read Read on X
In this thread we are going, finally, to implement Navier-Stokes simulation in Niagara. We should obtain something like in the gif below. #ue5 #niagara #vfx #gamedev #math
Following the steps in Stam's Stable Fluids paper, let's split our original problem into smaller ones. Basically, we solve the momentum equation (apply forces, advect velocity and diffuse it) and after that we force that computed velocity to be divergence-free using the pressure. Image
We know how to solve (from the previous thread...more or less) all the elements of last picture, except maybe the "advection" step. Luckily, it can easily solve using a method called "Semi-Lagrangian scheme". Again, I recommend you take a look to @nvidia GPU Gems blog. Image
Now, we can build the main "structure" of our Niagara emitter. Image
As usual, we're going to create some parameters and initialize them in the simulation stage called "Initialization", which it's going to run only one time. As usual we use a scratch pad to setup the dimensions of a Grid2D and Render Target, that we'll need in the future. ImageImage
In the "Compute Forces Constraints" module we set forces that affect the fluid field, like gravity. Additionally, we can set "boundary conditions" (based on static or dynamics object) for the fluid's velocity. It could also be called "Force + Boundary + User Interaction" module. ImageImage
All quantities in a fluid are transported by its velocity, included, the velocity itself. The module "Compute Advection" implements the "Semi-Lagrangian scheme". This module can be used to transport other quantities like ink or smoke. ImageImage
The algorithm is based on the "Lagragian viewpoint" of a fluid: the current velocity of a "fluid particle" is the velocity it had in a previous position. This previous position can be estimated using the previous velocity at its current position (figure in Stam's paper). Image
In this first simulation we are going to leave out the "Blur" module, because we want something with "low" viscosity. In a next thread, we'll implement it.
Now we have a non divergence-free velocity. We need to "extract" its divergence-free component. This is the aim of the next three modules.
The "Compute Divergence" module computes the divergence of the velocity field. ImageImage
Using the "Compute Jacobi Pressure" we can find, iteratively, the pressure that satisfies the Poisson equation. We can choose different "Num Iterations". As we know, a large number of iterations leads to a better approximation. ImageImage
Finally, we project the velocity into its divergence-free component using the gradient of the computed pressure in the "Compute Projection" module. This new velocity is going to be the input for the "Compute Forces Constraints" module. ImageImage
At this point we have a velocity field that follows, roughly, the Navier-Stokes equations. It seems a real flow. We can use this field to drive particles that live in the same Niagara system (reading the Grid2D from other emitter), but (afaik) you cannot share with other systems.
One way to do this is write the velocity field in a Render Target resource, like we did in a previous thread. In this case, we save in the render target the two components of the velocity in the RG channels (modulated to be in the range (0,1)). ImageImage
This render target "RenderSim", created in the Niagara system, can write an external resource using a "User Parameter". ImageImage
This is a good point to stop :) In the next thread we'll learn, among other things, how to use this simulation in other Niagara systems.

• • •

Missing some Tweet in this thread? You can try to force a refresh
 

Keep Current with Jose Moreno

Jose Moreno Profile picture

Stay in touch and get notified when new unrolls are available from this author!

Read all threads

This Thread may be Removed Anytime!

PDF

Twitter may remove this content at anytime! Save it as PDF for later use!

Try unrolling a thread yourself!

how to unroll video
  1. Follow @ThreadReaderApp to mention us!

  2. From a Twitter thread mention us with a keyword "unroll"
@threadreaderapp unroll

Practice here first or read more on our help page!

More from @jose_morval

Oct 15, 2022
It's time to solve some fluid dynamics equations! These are the well-known Navier-Stokes Equations which describe the motion of a viscous fluid. #ue5 #niagara #gamedev #techart #houdini #math
Image
There are three or four unknows in this system of equations, depending on whether we are in 2D or 3D case. The main unknows are: the velocity (two or three components) and the pressure.
The first equations, one for each component of the velocity, are called "momentum equations" and are basically Newton's F=ma applied to a little fluid element. The last equation is the "continuity equation" and it means that the flow is incompressible, i.e., density constant.
Read 26 tweets
Oct 12, 2022
Before getting into the fluid simulation thing we are going to talk about "programming" in a simulation stage and why do this. #ue5 #niagara
Let's suppose we have a scratch pad like the one in the first picture. As we know, this scratch pad runs for every cell in the Grid2D. But, what is it exactly "running"? Image
Every scratch pad, when we are in "GPU mode", is translated to HLSL code. Fortunately, Niagara can show us this translation. If you select your emitter (and you are in the "Generated Code tab") you should be able to choose "Particle GPUCompute Script". Image
Read 17 tweets
Oct 1, 2022
At the end of the last thread, we painted a moving circle in our Grid2D. Let's take a big leap transforming this circle into a simple "trace effect".
To do this, we're going to create a new Niagara system in world space that renders a single sprite, parallel to the ground, with a material that reads a texture (with the trace) created in Niagara. It's the perfect effect to learn a few things.
Formerly, this kind of effect was created using some render targets, a material and a blueprint. Now, is the same, but all inside Niagara and, in my opinion, in a more "natural" way.
Read 19 tweets
Sep 28, 2022
At the end of the first thread, we set the same value for all cells in the Grid2D. Now we are going to make something more interesting. #ue5 #niagara
(2/13) Let's create a scratch pad in the Simulation Stage. In this one, we are going to use the node "Execution Index", that assigns an integer for each cell, and set as the value of the cell. Previously, we normalize it using the dimensions of our Grid2D. Image
(3/13) For debugging tasks, it is useful ticking the "Preview Attributes" flag in the Grid2D definition. When you enable it, you should see something like the second image. In this case, I've chosen a low number cells so that we can see clearly the differences between cells. ImageImage
Read 13 tweets
Sep 26, 2022
I'm going to write a few shorts threads for those who are starting in the wonderful world of simulation stages in #ue5 #niagara. The ultimate goal is code a (simple) fluid solver in 2D/3D that allow us, for example, driving particles by fluid simulation in a similar way as games
(2/15) like Returnal or God of War does.
(3/15) As (I hope) you know, Niagara is a highly customizable particle system framework. You can put logic on every step: when the emitter spawn, when it updates, when a particle spawn and when it updates. Furthermore, you can add new attributes to particles to play with.
Read 15 tweets

Did Thread Reader help you today?

Support us! We are indie developers!


This site is made by just two indie developers on a laptop doing marketing, support and development! Read more about the story.

Become a Premium Member ($3/month or $30/year) and get exclusive features!

Become Premium

Don't want to be a Premium member but still want to support us?

Make a small donation by buying us coffee ($5) or help with server cost ($10)

Donate via Paypal

Or Donate anonymously using crypto!

Ethereum

0xfe58350B80634f60Fa6Dc149a72b4DFbc17D341E copy

Bitcoin

3ATGMxNzCUFzxpMCHL5sWSt4DVtS8UqXpi copy

Thank you for your support!

Follow Us!

:(