Initial Testing

This blog will cover everything that I have learned in my initial testing of fluid simulations. I'll be going over my workflow, my initial thoughts, and some quick comparisons between each technique. I'll also be linking all of the videos and documents I used to help me along this process.

---

The Test

The standardized test I planned to do was simple. I am going to drop a fluid ball onto a cube and compare the techniques side by side. The simulation will be contained in a 6x6 meter tank. Next, I'll note down the amount of particles and how long it took to render the simulation. The computer I am using to simulate and render have the following specs:

• Intel(R) Core(TM) Ultra 9 285k

• 128 GBs of DDR 4 RAM

• Nvidia GeForce RTX 5080

• Samsung 990 Pro 2Tb SSD

Please keep these specs in mind when you read about the rendering times.

Flip Fluids

First on the chopping block was flip fluids. Following this tutorial by Artivoxa and this tutorial by Mesrop Hovhannisyan, I was able to setup my first scene.

This first photo is the whole scene, and the two photos on the side are close-ups on the node tree. The whole scene looks mostly the same in every setup, so I will just show the respective node trees from now on. Using the points from volume node, I spread out points inside of the sphere. This acts as particles for the simulation to work. I then copied the particle separation in the DOP network's flip object and pasted the relative reference into the points from volume node. This particular simulation had a particle separation at 0.008. At frame one, the simulation was sitting at around 120,000 particles. One advantage of flip fluids is the reseeding option. This option automatically fills in thinner areas of the simulation to provide a smoother mesh. By the end of the simulation, there were around 2.67 million particles. The Houdini document for the flip solver is pretty comprehensive, and I found myself reading through it to help develop the initial test. You can read it yourself here. Next thing we need to do is mesh the model. As you can see, I used the particle fluid surface node to mesh my simulation. There is another workflow by converting the simulation into VDBs, and then meshing the VDBs. This node basically does the same thing under the hood, but you don't get to fine tune it as much as you could with the VDB workflow. However, for my quick tests I just slapped this node on and called it a day. The final render took 6 minutes to complete.

Vellum Fluids

Oh, Vellum fluids... I can't lie, for some reason I really struggled with this technique. I started with this amazing three-part tutorial series by Peter Quint. He talked through the pros and cons of Vellum fluids and goes through the settings pretty thoroughly, I would recommend checking it out yourself.

Here is my node tree after following Quint's tutorial. To be fair, the setup was actually pretty fast and simple. However, I mostly struggled with getting the motion of the fluid to look right. Most of the time the simulation ended up looking and feeling like sand. I also came across this Houdini document that compares the two techniques. You can read that here. The main thing I noticed was that there was a lack of a reseeding option. This meant that the particles in the simulation are fixed. Also something to note from the document was the amount of particles used in the simulation would affect the volume of fluid that would be generated. That being said, I decided to settle at 833,000 particles, thinking this would be a great compromise for the caveats above. However, the final render time for this simulation was 17 minutes, the longest by far. Maybe this was just a bad test for Vellum, or maybe I did something wrong, but this is definitely worth revisiting in the future.

MPM Fluids

Last but not least is MPM fluids. Using this tutorial by Eduardo Becerril, I was able to come up with this node tree setup.

I also came across this document that compares MPM to the other solvers. The main reason to use this solver over the other two is straight forward: if you need multiple materials to interact with each other. This test, however, doesn't have that. That being said, the document listed above said that MPM acts most similarly to FLIP, so we should still be able to see somewhat similar results. While there is a reseeding option, I found that it didn't affect the particle count too much in this test, so I left it off. With 720,000 particles, the final render took a little under 7 minutes to render.

Results

Here are all the rendered results. From top to bottom, we have Flip, Vellum, and MPM. They are all rendered in solaris with an HDRI that I pulled from PolyHaven. From these small tests, here is what I've learned. FLIP is the go-to solver for detailed, high accuracy fluid simulation. It does well in faster environments like splashes. However, it can only interact with collision geometry. Vellum is good in small-scale simulations, such as sweat and blood. They also have the ability to interact with other fluids (like oil and water) as well as soft-body collisions (like cloth). Also, remember the three-part tutorial series with Peter Quint? I actually didn't watch the third video as it covered the minimal solver workflow. However, that might be what I needed to go through to achieve better results. Especially for a test like this where I didn't need soft-body collisions. You can read more about it yourself here. The main drawback with this solver is the lack of reseeding and they require more sub steps. Finally, MPM is best when interacting with multiple materials. It is best suited for materials that are elastoplastic, or "chunky", such as snow and soil/mud. Those are my conclusions after these quick tests. I hope you found this blog useful somehow! Next, I have a creative project planned and I will post updates about that as I go along. See you in the next post!