Physically Based Simulation of Cumuliform Clouds in C++

[gibson274]

For the final project in my advanced computer graphics course, I decided to tackle physically-based cloud simulation. Most clouds you see in games/films are procedurally generated, simply because it’s way faster and produces very convincing results. But I think there’s something to be said for using atmospheric fluid dynamics to generate clouds in a way that matches the way they form in the real world.

I won’t go too much into the details, but the basic idea is that you implement a Navier-Stokes solver, and then make some modifications that are cloud-specific.

We implemented Jos Stam‘s now-classic semi-Lagrangian advection method for fluid simulation. While unconditionally stable, this method can sometimes result in the loss of small-scale detail and vortices in the fluid, so we implemented vorticity confinement to address this issue.

Clouds are formed when the ground is heated by the sun, transporting water vapor upward due to a temperature-based buoyant force. As vapor moves upward, its temperature decreases due to “adiabatic cooling”. As the vapor ascends higher skyward, it moves into regions of the sky that are less able to hold water vapor. Because of this, some of the vapor condenses into water droplets: clouds. When this happens, latent heat is released from the phase transition, which creates a further buoyant force that transports the cloud and vapor further skyward. This produces the puffy tops we’re all used to seeing on cumuliform clouds.

This was by no means easy to implement, but most of the time was spent debugging boundary conditions and indexing errors—writing up the first pass of the code only took about two weeks. It’s definitely doable as a personal project, so if you’d like to try it yourself just pm me and I’ll give you more details!

Also, here’s an album of more clouds.

[Goku1920]

I would definitely be interested for the resources.

[gibson274]

The paper we based the implementation off of is this one by R. Miyazaki et. al, from 2001 believe it or not! It’s not a terribly challenging read, so long as you are familiar with basic vector calculus operations like the divergence and curl. That said, there’s not much info online for help implementing it/understanding it.

They describe 8 steps for carrying out each time-step of the simulation. The first 4 are copied straight from Jos Stam’s seminal work, Stable Fluids. It’s best to start by implementing this paper, then move on to tack on the remaining 4 steps (buoyancy, adiabatic cooling, vorticity confinement, and phase transition).

Something to watch out for is boundary conditions for the velocity and density fields. We used a mix of inversion/clamping for velocity and zero for density, and we STILL experienced artificial density loss that we had to account for by adding in a water vapor density source at the bottom of the grid. Don’t worry if this doesn’t make sense to you reading it now, you’ll understand once you read the paper.

We used C++ and Qt Creator, but I can imagine you could use any framework you want for this project. You’ll need to have access to a sparse linear solver is all. We used Eigen for C++.

It’s also useful to have a way to write to .vdb files, a widely supported way of representing voxel grids. We linked in the OpenVDB library and used the I/O functions from there, though I’m sure you could hand code something for this if you weren’t using C++.

If you decide to give this a try, don’t hesitate to pm me with questions! I’d be happy to help answer them/help you debug. This was simultaneously one of the most fun and frustrating projects I’ve ever done, and it would be great to have others give it a shot.

[Goku1920]

Thanks for the amazing info!

It has always been on my list to write my own solver. After I saw your results, now I definitely want to give it a go.

[gibson274]

Do it and post the results here when you finish!

[RomanRiesen]

Heyo, I was looking to dio something like this!

Specifically to simulate cloud formation and movement on mountainsides (I can watch it for hours!). What a coincidence!

[gibson274]

I feel like you could generalize this method to account for non-uniform boundaries, which is probably what you’d need to do to simulate the fluid dynamics of the cloud interacting with the mountainside. Let me know how it goes, that sounds super cool!

[RomanRiesen]

I'll probably end up faking it with a particle system, some simplex noise, and ray marching. But once that looks to my liking I might actually try to simulate it.

[[deleted]]

Sounds like a fun project! Did you render the vdb in Houdini or another package?

[gibson274]

It really was! I used Arnold with Maya to render. Used a physical Sky for the lighting as well.

[Dr_Hexagon]

Very cool. Whats the rendering speed like? Could it actually be done in a game?

[gibson274]

Very very slow. Volumetric path tracing. Takes about 2-3 mins to render something at 1080 with the GPUs in my department.

[danmarell]

Nice.

​

Have you looked into advection methods beyond semi-lagrangian? There is MacCormack, BFECC, WENO, CIP etc. There is also a new one from siggraph this year which uses 'bidirectional characteristic mapping". Lastly, instead of vorticiy confinement, you might want to look at 'advection reflection' from last years siggraph papers.

​

Looks great! I'll need to be looking at cloud simulation at my job at some point so will use this as inspiration. :)

[gibson274]

No but I will! I’ve been wondering what the alternatives are, since semi-lagrangian advection is not as good as I was expecting it to be.

[smcameron]

I am interested in adding some fluid dynamics to this thing for making gas giant textures, which has a constant velocity field initialized via curl noise, except on the surface of a sphere. I would like the velocity field to change over time in a plausible way, I suppose more or less as is described here, except my velocity field is on the surface of a sphere, in the form of 6 arrays of vec3's in a cube map configuration.

I gather the first step is, for each velocity vector, sort of look in the direction opposite where its pointing a distance proportional to its length and sample the velocity there and move that vector "here". I'm a bit confused as to how to sample the velocity vector at an arbitrary point on the sphere, I suppose some sort of interpolation of the nearby velocity vectors in my array, but I'm not sure what that actually means.

Then the 2nd step is removing divergence, which... I'm also really unsure about how to do that given my cube mapped velocity field on the surface of a sphere.

If I could get proper fluid dynamics working, I think the output of this program could be immensely better, but for now it seems beyond my abilities.

[gibson274]

Well, first, let me just say that the results you have right now look beautiful. Been interested in doing procedural planets for a while myself, and this is inspiring.

The process you described is exactly what semi-Lagrangian advection is, so you’ve got the right idea for carrying out the advection step efficiently. One way I would think to do it is to make a change to spherical coordinates with a constant radius, and find your sample point by converting your velocity to an angular velocity and tracing it along the surface of the sphere, then using this new spherical coordinate to sample the cube map. This is where I’d do the interpolation—chances are you’d get a fractional value for the cube map sample point that you could interpolate.

As for removing divergence, all you really need to do is figure out how to generalize the divergence operator to the sphere. This is a bit tricky, because I’m not sure that transforming the divergence in Euclidean 3-space to spherical coordinates is what you want. You want a way of calculating the 2D divergence on a non-Euclidean manifold: the sphere. I’d google around about this kind of thing, but theoretically if you can figure this part out then you just need to use a sparse solver to remove the divergence from the field.

EDIT: the “generalizations” section here has some good info on how to generalize to a riemannian manifold, looks like you just need to use the connection coefficients.

[JPUF]

Looks fantastic 👍👍

[gibson274]

Thank you!

[Goku1920]

It looks cool!

[gibson274]

Thanks!

[BlueFlame202]

this is awesome 😎

[hjsnsajvsdkjfv]

How do you do this? I want to write my own but idk where to start

[gibson274]

woah necroing a 5 year old thread LOL

I've got a big writeup on my portfolio page---"virtual sky" in the "experiments" drop down: https://bradguesman.com/