Generally, the process of creating animation for particle-based simulation research can be divided into the following 5 steps:

1. Create a 3D scene.

2. Import simulation data.

3. Polish the 3D scene.

4. Render the animation.

5. Generate the video.

Step 1 and 3 are the steps that involve creating 3D art using CG softwares, involving 3D modeling, texturing, lighting, and more. I suggest you to check out Blender if you are a CG beginner.

step 2 and 4 are the main steps that involve scripting, and would be our focus in this blog.

In the first step, we need to create a 3D scene that represent the environment of where the simulation takes place.

Usually, before we conduct any simulation, we have imaged which real-life or imaginary scenario it will be applied. So now it is the time for you to set it up.

It can be something complex, but can also be something as simple as a white backdrop or wooden table.

There will be different simulations involving different types of objects, like rigid bodies, fluids, smoke, fire, etc. I'm using particle-based simulation as an example because it is what we have mainly worked on. Particle-based method is versatile and can simulate different types of objects and phenomena, like viscosity, coiling, and buckling. 

Suppose we have a batch of particle-based simulation data ready, usually exported in plain text format (.txt), and now we want to import them into the scene.

We need to convert the data first so it's compatible with the scene, there are two ways depending on the needs:

1. 1. Render as mesh.

   2. Render as particles.

Here is a comparison for the 2 methods:

Mesh approach: use convert.py to convert TXT files into vertex-only OBJ files, import the vertex-only OBJ files into Houdini and convert them into meshes, export mesh OBJ files from Houdini, and import them into Blender or Maya.

Particle approach: use convert.py to convert TXT files into RIB files, render the RIB file sequence with RenderMan, from Terminal or your Command Line Interface.

💡 Side note: RIB is the file format that allows RenderMan to render from Terminal with command: 

$ prman -progress <file-name>.rib

After running the script, we obtain a sequence of OBJ (vertex-only) or RIB files that describe the particles, however, the two approaches will have different level of information at this step.

Mesh approach: vertex-only OBJ file only include information of the particle position. We need to use Houdini to convert vertex-only file sequence into mesh sequence.

Particle approach: RIB file include information for the particle position, size of the particle sphere, as well as their shading materials. The particle RIB file sequence is ready to render with RenderMan along with the scene in RIB format, which is usually another standalone RIB file.

💡 To learn how to use Houdini to convert vertex-only OBJ file into mesh, please check out this post I created: Houdini Particles to Mesh.

Now you've created a 3D scene, import the simulation data into the scene, and you can start polishing the scene.

There are several components you can consider when polishing the scene:

• Finding References

• Detailed Modeling

• Lighting

• Shading and Texturing

• Camera Setup

This is the part where you can be creative and detail-oriented. I will leave the exploration to you!

Now, I suppose you have your scene that is render-ready.

There are generally two ways to render a scene with the simulation data:

1. 1. Render on CG software with built-in renderer.

   2. Export the scene to RIB files and render with RenderMan from Terminal.

There are advantages and disadvantages for each approach.

If we choose to render with built-in renderer, it is very easy to start rendering and we do not need to consider the OS. However, we can only render on the current machine, the software GUI must be kept open, and the rendering will terminate if the software crashes.

If we choose to render with RIB files, we can distribute work seamlessly on different machines, and it is easy to control remotely via SSH, and there is no need to keep the software GUI open. However, we need to modify RIB files according to the OS and version of RenderMan, and it requires planning with multiple machines that may have different hardware thus different rendering speed, and we usually need to rely on the CG software's support to export the scene as a RIB file.

Here is a script - render.py - to render a sequence of RIB files if you select the second approach. Run it with the command:

$ render.py <data set> <file prefix> <start frame> <end frame>

After running the script, we obtain a batch of EXR image files.

💡 EXR or OpenEXR, is a file format used to store high-dynamic range (HDR) image that contains a greater range of brightness than traditional images. Rendering a scene into EXR format delivers a better results than rendering the scene into PNG format.

To summarize, we briefly discussed how we can create an animation given a data set of physics-based simulation data, with some Python scripts I created.

1. Create a 3D scene.

   • Using a CG software, e.g. Blender.

2. Import simulation data.

   • Convert TXT file data into OBJ file (mesh approach) or RIB file (particle approach) with convert.py.

   • Mesh approach: use Houdini to convert vertices into meshes.

   • Particle approach: use convert.py to finalize the particle positions and shading.

3. Polish the 3D scene.

   • Consider texturing, shading, lighting, and camera.

   • Export the environment setup of the 3D scene.

4. Render the animation.

   • Render the animation with CG software's built-in renderer.

   • Or, render the animation with render.py.

5. Generate the video.

   • Use bash scripts and Mitsuba renderer utilities.

Feel free to reach out to me if you have any comments or questions.

Happy rendering! 💐

Best,

Laurel Han