My best projects of the year

Hey! Here is my second entry to the Rookie Award. I learned a lot this year, especially in FX, Solaris and pipeline. I would like to share you four of my latest projects ! I'm currently in fourth year at Artfx, Lille (France) specialized in FX. This is my 2023-2024 journey... 

1. Dunkirk burning Spitfire

Here’s a project I completed last summer. As a fan of the movie Dunkirk, I decided to recreate one of its iconic shots. My goal was to learn the Axiom Solver from Theory Accelerated. The project was created using SideFX Software's Houdini. It was a great exercise to match the reference footage. While it's not perfect, I learned a lot !

Process :

I sourced a 3D model of a Spitfire online. The mesh had several issues, so I worked on cleaning it up. I used blasts, Voronoi fractures, and numerous transformations to match the reference.

Afterward, I identified three main sources of fire by studying the reference footage: the right wing, a small burning object on the ground, and the primary fire on the right side of the Spitfire. The setup is similar for all three.

First, I painted a mask attribute and added attribute noise using VOPs. I then used this mask to multiply source attributes like density, pressure, and temperature. I added different-sized noises and merged them.

Next, I created spheres as the center of each fire source. This is the area where the fire is larger, hotter, and carries more pressure. I transferred attributes by distance and multiplied my source attributes.

After sourcing the fire, I rasterized my points to create my emitter and simulated the fire layer in Axiom.

I then created the smoke layer by merging the same emitter as the fire and incorporating the fire velocity field.

To generate embers, I used the advect by volume node to capture the velocity fields from the fire and smoke.

For the debris, I emitted smoke points into the fire emission area and established collision behaviors such as sliding or bouncing.

Here is the setup!

In terms of look development, I used Solaris for the first time, which introduced me to the USD pipeline. While I made a few mistakes, the process was fascinating.

Rendering was done with Karma CPU in Houdini 19.5. Alongside this project, I created a "Burning Lab" to wedge pyro parameters using a TOPnet.

The compositing work was done in Nuke.

2. Jungle river

Jungle river was a fascinating project as I had to collaborate with a character designer, an animator, and a CG generalist. I was responsible for developing the pipeline we worked with and decided to use USD and Solaris.

First, let's discuss the water effects. I had to generate a constraint based on the environment artist's work. I used multiple operations to create a closed shape of the environment and then converted it to a VDB.

Next, I needed a FLIP source to avoid lengthy FLIP pre-simulations. At the top of the waterfall, I created a FLIP source with velocity to feed the waterfall.

Then, I used a DOP network to simulate the FLIP. It was challenging because I needed to find the right amount of sourcing and a pleasing shape. So, I worked with the environment artist to add or remove some rocks.

After that, I prepared my FLIP to become a whitewater source by keeping only the surface and velocity fields.
I also created a custom water mesh using VDB operations and used an attribute VOP to retain only the water's surface.

For the whitewater effects, I used a whitewater source and incorporated vorticity, acceleration, and curvature sourcing. I rasterized these points to create a subtle smoke effect at the surface of the whitewater emission. Using the whitewater source points, I applied a whitewater solver. After the simulation, I rasterized the whitewater points to create a VDB of the simulation.

I used topnet to improve my workflow.

To add realism to the scene. I've generated a wetmap using attribute transfer into a solver.

Next, it was time to ingest my FX into Solaris. I created a custom Solaris HDA to import my FX. This HDA allows for the ingestion of VDBs and geometries into USD. It creates a USD file for each frame of the simulation, stitches them together, and ultimately creates a cohesive USD file. You can download it on my Gumroad.

At the start of the project, I was the only one familiar with how Solaris works. So, I took the opportunity to expand my knowledge and develop the project's USD pipeline. It was challenging, and I made many mistakes, but I learned a lot. It allowed me to understand primitive kinds and layering in USD.

The rendering was done using Karma CPU.

3. City Explosion

Here is one of my latest pyro projects. I practiced layering with my main explosion setup in Houdini by adding a blast, a shockwave, trails, sparks, and debris. I also created a procedural destructible building HDA to enhance the render. Additionally, I created a window destruction simulation to further integrate the explosion.

Process :

I started by creating the layout. My goal was to give the impression of being in a bombed city from the perspective of a 4x4 vehicle. To achieve this, I developed a Houdini digital asset for a procedural destructible building.

First, I scattered some points and copied boxes onto them. Then, I used poly extrude to bring them to the ground level. After that, I divided them by floors and created tools for inner walls, windows, and other structural elements.

All the buildings had to be destructible, so I was careful to avoid any interpenetration of elements. Then, I wedged different buildings and fractured them using material fracture. I used constraint rules to create connections between the different parts of each building.

To destroy them, I used a foreach loop to create metaballs based on a scatter. These metaballs were injected as velocity forces in the RBD solver to procedurally destroy the buildings. To post-process the buildings, I used rbddisconnect faces to prevent shader issues and added my material attributes.

After that, I created the ground, which was full of craters.

Time to explode things... Wait, why? Initially, I wanted to create an explosion, but it seemed odd to explode nothing. So, I decided to create a large smoke plume with fire to justify the explosion. This would be a gas explosion. For the fire setup, I used a pyro solver instead of axiom, similar to the Dunkirk effect.

After setting up the fire, it was time for the explosion! I used the pyro burst source with multiple emitters to create a large explosion. I also added pyro trail paths to refine the shape of my emitter. This process was easier than creating the procedural building HDA.

Shockwave: Again, I used a pyro burst source and employed a ray to stick it to the ground.

Blast: This was a pyro solver advected by the velocity of a rapidly expanding mask along the ground and buildings.

Debris: I customized a pyro burst source to create points moving at high velocity, then used copy-to-point with fractured box pieces to represent the debris.

Window Building Destruction: This was a challenging task that required optimization and high memory usage. I took three buildings, destroyed them, and separated the windows and other elements as colliders. I used a metaball scatter on the explosion source and re-fractured the materials. The velocity field from the blast did not advect the RBD as well as expected.

I also used topnet to create a wedging pipeline.

This project was set up in Solaris, rendered with Karma CPU, and composited in Nuke.

4. Falling Piano

Here is one of my live projects. Last year, I worked on a project featuring a destroyed piano in Unreal Engine. I wanted to create a live-action side project using this piano.

Process :

I filmed the footage with a Sony A7sIII, created the HDRI with a Theta camera, and captured Lidar data with an iPhone.
I denoised the footage, removed lens distortion, and tracked the shot. After exporting the camera data in Alembic format, I reimported it into Houdini and matched the camera with the Lidar data.

The modeling of the piano was done by William Ariza. The main challenge of this project was creating all the constraints since William modeled all the small pieces of the piano. I had to establish hundreds of constraint rules between them.

Then, I created sources for the debris and smoke effects.

The rendering was done in Solaris, and I used the background plate node to cast shadows.

The End...

If you want to watch my demoreel: