ESTEBAN VASCO - FX REEL

MAN OF STEEL SHOT

Destruction effects and Superman are two of my favorite things ever, so when I saw a building destruction shot on the movie "Man of Steel", I knew I wanted to make something like that. It wasn't my objective to try and match the original shot 1:1, but rather to use it as a starting point for my shot.

Building Prep

I decided to use the ready-for-destruction building provided by Rebelway. The first thing I did was to determine the area where the main effect would take place, for which I used a noised sphere to boolean out the area of the building that I needed.

Once I had this area, I remeshed the geometry that would then be the concrete of the building to avoid issues after fracturing and used the remaining area to create a proxy collider for all the upcoming simulations.

FRACTURING

Glass: I used a Voronoi Fracture for the glass to try to get something similar to tempered glass while still maintaining a reasonable amount of pieces.

Concrete: I used Voronoi Fracture, adding noise to the geometry before fracturing and restoring its original position afterward to get jagged edges on the pieces. I also created a density attribute which is greater the closer the points are to the impact sphere so that I can control the size of the fragments and get smaller pieces where the main impact would happen and larger pieces on the outer area.

High-res concrete: To add more detail to the concrete fracture, I isolated the inside faces, subdivided and added noise to them. Also, I created UVs for both the inside and outside faces using the UV Project node and the Labs Inside Face UVs node, respectively.

Extra geometry: I used Boolean Fracture for these floor tiles with the same density attribute as for the concrete but I was getting way too many tiny fragments. To solve this, instead of removing them, I used the xyzdist() and prim() VEX functions to inherit the name from the closest largest piece to each tiny piece so that the tiny pieces become one with the larger ones. 

CONSTRAINTS

For the concrete constraints, I created noise to vary the strength of the constraints so that not all the concrete chunks hold as much as the rest by assigning a different attribute to those constraints that had a certain noise value.

This group of constraints are those connecting the bricks to the concrete and I wanted to treat them independently from the rest so that I can make them stronger than the rest of the bricks constraints.

For the Bricks, I knew I had to create clusters as bricks generally tend to stay together in large chunks instead of just flying away independently. So I used the Cluster node to create a cluster attribute and then used that to identify those constraints connecting different clusters so that I can later make them weaker than the internal brick constraints.

For the floor tiles, I knew I wanted the larger pieces to be stronger than the smaller ones, so I promoted the volume attribute from the pieces to the constraints and used that to drive whether the tile constraints were going to be stronger or weaker.

Once I had all the constraints primitives ready, it was time to set their properties. So I used all the previously created attributes to properly filter the constraints in one wrangle and specify their type and strength values. The final values were reached after many iterations of the simulation to get a nice result.

SIMULATION

I set up the simulation by packing the previously fractured elements, and bringing in the constraints and the collider previously mentioned, as well as one point representing the place where the impact would happen (the centroid of the sphere used for fracturing).

Inside the DOP network, I used a geometry wrangle to create a custom force that would drive the destruction. This force is calculated by measuring the distance and direction of each piece to the impact point. The pieces that are closer to it receive a much greater force than the pieces that are further.

Also, after some iterations, I noticed that I needed to decrease the force only for certain elements that were flying out too much, so I identified the pieces by their names and modified their force values until I was satisfied with the result.

RETARGETING

To transfer the movement of the pieces to the high-res fragments, I used a wrangle to build a custom Transform Pieces node by applying the transformations using the packedfulltransform and transform matrices, which is a good practice to become comfortable using VEX and understanding how information is transferred in Houdini.

CUSTOM DEBRIS SOURCE

To have complete control over my secondaries sourcing, I attempted to create a custom Debris Source as Louis Manjarres showed on his Destruction FX Workshop. 

To do this, I first scattered points on the inside faces of the RBD pieces and used a loop to store the primitive number, UV coordinate, and distance to their closest inside faces other than their own. These attributes would then be useful to filter out the points for sourcing in terms of distance and speed.

Once I had this, I applied the transformations back to the points.

To filter out the points, I used speed and distance thresholds so that points would emit only in specific moments. I got to these values after some tweaking depending on whether I needed more or fewer points.

I used a Solver to create an Age attribute that would then drive a density attribute to control a Point Replicate node, so that I control when I get a larger amount of points and have it fade out as the points age.

GRIT SIMULATION

Inside the POP network, I made a very simple setup, bringing in both the RBD collider and the rest of the building collider. 

I applied the same impact force as I did on the RBD pieces to have a coherent behavior and gave the particles a short lifespan. However, for those particles that collided with the building ground, that is those that have stopped, I am subtracting from their age so that they never meet their life and don't die because it would look weird to have particles standing on the ground disappearing.

Here is a previz of the final grit simulation visualizing the age attribute.

DEBRIS SIMULATION

I used Voronoi Fracture on a cube to get nice pieces to scatter and use as debris. I assigned them a unique Variant attribute to then use inside the Copy to Points node.

For the points, I used the same Debris Sourcing as for the grit sim, just tweaking the values to get a different amount of points on each frame.

I created a random Variant attribute for each point as well as a Pscale attribute controlled by a ramp. I did this so that I could control having a lot more smaller pieces than larger ones.

FInally, I gave them unique name attributes using the point and frame numbers so that Bullet doesn't complain.

Inside the DOP Network, I brought in the RBD pieces and set them as Animated Static and the rest of the building collider as a Static Object.

I used a Geometry Wrangle to also apply the impact force as well as with the other simulations.

To source in the actual debris, I used a SOP solver and an Object Merge node to call in the instances I created earlier. 

DUST SIMULATION

I needed to create a Custom Clustering Tool to be able to simulate the smoke for the whole scene. After some tweaking, I decided to go for two vertical clusters, but the tool can be customized to get multiple clusters and decide whether you want vertical or horizontal clusters.

To start, I made a Camera Frustum using the toNDC VEX function to optimize the scene.

I procedurally generate bounds that can be subdivided into the specific amount of clusters that we want, and then use that to group the points and blast them.

I set the controls on a Null to determine which cluster I want and whether I want vertical or horizontal clusters. This way it's easier to select the cluster I need for the simulation.

To create the Density attribute, I used the speed of the particles to get more smoke where the sourcing points are going faster.

I rasterized that density as well as the velocity of the particles and brought that into DOPs to create the sim.

For the sim, I brought in the Density and Velocity sources, I didn't need to use Temperature in this simulation.

 I added Disturbance to add breakups to the smoke and Dissipation to make it vanish over time.

The velocity was giving me some trouble as it was affecting the smoke too much, so I ended up animating it on specific frames to get the result I wanted.

Things got a bit more complicated when I brought in the collision from the RBD pieces as the velocity from that was causing big stretches on the smoke.

To work this around, I faded out the velocity on the collider by its distance to the SDF, which was controlled using the Voxel Size and Exterior Band used to create the VDB.

I also set the velocity sourcing to Pull on the DOP network as I noticed that it gave me nicer results than Add, and animated its influence over time until I was satisfied with the result I got.

After more than 20 iterations, I ended up with a simulation that I was happy with.

Here are the two clusters. I then used a VDB Combine to merge their fields.

CHARACTERS

I got the mutant and his animations from Mixamo. I used a Blendshape node to blend between two animations that made sense in the shot context.

For Superman, I found a free 3D model online and animated it on Mixamo. 

I used Vellum to create a cape and added some Wind forces to make it look like it was being affected by some strong movement caused by Superman's flight.

I also created a smoke trail for Superman, for which I used a Trail node to create copies of him and turned that into a density VDB, always making sure to add some velocities with noise to create cool shapes on the smoke.

GLASS SIMULATION

To activate the glass for the first shot, I used the Superman character trajectory to transfer an attribute by proximity to the glass pieces.

I also used a SOP Solver to get the maximum value between the current active value and the previous frame's active value, so that if a piece has already been activated, it stays active.

I added a custom velocity attribute that will only be applied to those glass pieces that are activated by Superman.

In terms of constraints, I kept only those connecting glass pieces to the concrete RBD pieces and made them Unbreakable Glue so that I get glass pieces stuck on the RBD walls.

Inside DOPs, I used a Geo Wrangle to get the pieces to inherit the velocity attribute I created in SOPs only on the frame that they are activated; I limited this to only happen on the first 30 frames because, after that, the main impact force takes over and all the pieces get activated.

The Hard Constraints were part of some testing I was doing, but ended up just using Glue Constraints.

Here is what the final glass sim looks like in the viewport.

ENVIRONMENT

I got these buildings from a Kitbash pack, chose the ones that looked better, and then created a camera frustum with a box to group and keep the geometry that would be visible to the camera.

RENDERING

I used Redshift for rendering. All the red nodes are the actual render nodes and the blue nodes are where I made Proxies for Redshift to optimize the rendering process for those assets that needed it, like the RBD concrete or the building itself, which were heavy geometry that really benefited from the proxies.

In general, I set each render node with the necessary AOVs to have control over their look in comp, some of these include Diffuse, Specular, Reflections, Refractions, and GI for geometry and Volume Lighting, Fog Tint and Fog Emission for Volumes.

COMPOSITING

Compositing is pretty straightforward, I first split each render pass into its AOV components and tweaked them a bit to my liking, added a sky image, and matched colors to make everything blend.

Then, I created a shockwave when the impact happens, I used an ellipse to mask out effects from the Glass node and Grade node so that the expansion warps the image and gives it a greener tint.

Finally, I added some camera effects like chromatic aberration, grain, and camera shake when the main impact hits.

To make both shots blend better and get the impact to feel stronger, I made a double cut, which means that the impact happens twice visually in a very short amount of time, making it feel bigger.

CAR ON FIRE

This project started as a fun little practice to see if I could make some fire on my own. I quickly started to add more and more to it until I got this result. I have to say that this isn't the final shot as I'm still adding more stuff to it, but I do think it is still worth sharing.

FIRE SIMULATION

To create my source, I downloaded a car model online and isolated the faces by their normals as I didn't want to emit from the entire car.

Then I scattered points on that geometry and assigned Temperature and Burn attributes, I didn't assign a Density attribute here because I'm going to emit density from the flame inside DOPs.

Once I had these attributes, I added some noise to them to generate nice breakups and avoid uniformity, I rasterized them and I was ready for DOPs.

Inside DOPs, I made a pretty straightforward setup where the main focus was on the Microsolvers that would dictate the shape of the simulation.

I added a Gas Dissipate node to add Diffusion to the simulation so that it blurs out just a bit. I also added two Gas Disturbance nodes, one with Rotational Force enabled, which affects the Flame field, and one affecting the Density field to disturb the velocity field of the smoke generated by the flames and avoid mushroom shapes. I also added two Gas Turbulence nodes to simulate a wind force that would give the smoke nicer movement patterns. Finally, I added a Gas Shred inside the Solver to help with breakups on the flame field.

After some tweaking on the sim, I ended up with a result that I really liked.

EMBERS

For the embers, I used the velocity field from the fire simulation inside a POP network to advect some particles through it and get some coherent motion.

The real magic comes after the sim, where I am controlling the look of the embers. I didn't really want to rely on motion blur to get the particles to look like lines as it would be very hard to control, so I decided to create the lines myself.

I started by reducing the number of particles from the sim with a wrangle where I can very easily control how many particles I get without resimming.

Then I offset the particles along their velocity vector so that, in essence, I can have them trailing behind the original particles; also, I multiply this by a ramp driven by the normalized age of the particles so that the distance between points (and, hence, the length of the lines) would decrease as the particles were born and die out.

As these particles were duplicates of the original ones, it was easy to create lines between them using their ID attribute. 

Once I had these lines, I resampled them and created a width attribute to drive their thickness and applied some noise to not have perfectly straight lines.

ENVIRONMENT

I got the assets for the environment from a Kitbash pack, I knew I wanted to give this shot an apocalyptic vibe, so I did my best to layout some of the buildings I like the most together with some debris scattered both in the foreground and midground of the shot to not have it look empty.

Something that I'm currently adding to this shot is more details on the ground. I wanted to make it feel destroyed, so I made some holes in it with the help of fracturing techniques.

I used Voronoi Fracture based on the points from a Point Replicate to create loads of pieces on certain areas of the ground. And I also used Boolean Fracture to create transversal cuts all around the ground.

Once I had the fractures done, I measured the volume of the pieces and blasted the smaller ones to get the holes I needed.

Now, as the shot has rain in it, I also wanted to try to add puddles where these big holes are. So I used them to create bounds that I used to boolean a grid and get geometry only where those holes are, and I used a Ripple Solver to create the deformations on the grids.

RAIN SIMULATION

I used a grid as the emitter for these particles. Inside DOPs, I brought in some of the geometry from the environment, mainly those assets that are closer to the camera, and used them as colliders. 

This is relevant because I'm using a Point Replicate only on the particles that collide, to mimic the splash that happens when rain droplets hit something.

I applied the same treatment as with the embers, offsetting the particles along their velocity vectors and giving them some width and noise to avoid uniformity.

Another extra effect that I'm working on is these rain droplets that are emitted from the surfaces.

To make it, I scattered points on the surfaces that were closer to the camera and created a mask attribute from a Turbulent Noise in VOPs, and I animated its offset to not have a static source.

Inside the sim, I added a wind force that drives the direction in which these droplets move. However, there were some surfaces that didn't align with this direction because of their layout, so I grouped them and reversed the direction to what made more sense for them.

RENDERING

I used Redshift to render this shot. However, I didn't need to create any Proxies for it as I did for my previous shot.

I set each render node with the necessary AOVs to have control over their look in comp, some of these include Diffuse, Specular, Reflections, Refractions, and GI for geometry and Volume Lighting, Fog Tint and Fog Emission for Volumes.

I also created a Redshift Light and gave it the render of the Fire pass as a texture, this helped tons with getting nice lighting coming from the fire and interacting with the rest of the environment.

COMPOSITING

Compositing for this shot was pretty straightforward, I brought in all the passes that I rendered, split them using the Shuffle node, and color-corrected them to give the shot a dark apocalyptic vibe.

Something that's worth noting is that I tried to create Depth of Field in comp using the ZDefocus node, which uses the Depth pass from rendering to determine where to blur, and I used a custom image of Bokeh to give it a nicer look.

I also added some Glow layers to make the fire stand out and some Camera Shake to give the shot overall a bit more interest and make it feel a bit more dynamic. 

VORTEX PORTAL

In this project, I wanted to test how far I could go in terms of layering different FX on top of each other. I was inspired by a shot on the TV show The Sandman, which sparked my creativity at a moment when I was feeling quite blocked and got me out of my comfort zone. Finishing this project was the first step to really feel like I was learning how to work with Houdini.

CURLY PARTICLES

The core of the effect relies on these curly particles and the vortex volume. Both FX were made with this emitter.

I created a density attribute with an animated noise in VOPs, and displaced the geometry with other noise patterns to have more interesting shapes.

For the particles, I used two velocity fields. The first one comes from the Curl Noise, which uses a VDB version of this emitter to make a velocity field that has higher values around this SDF.

The second velocity field has a vortex motion that I got from the Volume Velocity node, so my particles had their main curly motion as well as this circular motion around the emitter.

Once I had my particles simmed, I gave them some color using another noise pattern made in VOPs from the rest position of the particles.

VORTEX VOLUME

For the main volume, I used the same vortex velocity field so that its main motion is circular. I used the same emitter as with the particles but tweaked the noises to have different patterns and only created a Density attribute.

Inside DOPs, I brought in the vel field and added some Dissipation, Turbulence, and Confinement Microsolvers to add some breakups and give the volume some nice shapes.

Once I had my sim, I went into VOPs and added a multiplier based on the Frame number to add a fade-in for the smoke, as I noticed that it appeared a bit too abruptly.

LIGHTNING

I started by emitting a few particles from the main emitter, which I then rayed on its surface to have them attached to it.

Then I jittered those particles and rayed them back on the surface and merged them with the original ones, now I could create lines between these points using their matching IDs.

Once I had these lines, I initialized some attributes like Pscale, Width, and some custom attributes like probability and a mask. All these attributes are based on ramps that are driven by the Curveu attribute so that I can control how they change along the curve.

Then I used these attributes inside a loop to create branches for each lightning curve. Especially the probability attribute that drives how many branches I'll get.

Once I had that, the only thing left to do was to add some noise to the curves to make them look like actual lightning. For this, I used the mask attribute setup earlier to make sure the noise is only applied where I need it.

This same setup can be used to create lightning from any other source, like here where I used some animated circles to spawn particles and ray them on the ground, and build more lightning from that.

ENVIRONMENT

For this project, I used some assets that I got in the Destruction FX Workshop from CGMA taught by Louis Manjarres. I really liked the old, mysterious cave vibe that I got from these assets.

I later assigned a rock material to them to convey this feeling that we're inside of a cave.

GROUND PARTICLES

I took the platforms from the environment and scattered a bunch of points on them.

I also created a curve that goes along the main emitter, the objective here is to create a tornado-like force that makes the particles go toward the curve and go around it.

I made this force inside a POP VOP. The force consists of three main components:

- Inward Force: this makes the particles go from their original position to the curve, like an attraction force.

- Swirly Force: it's based on a cross-product that makes the particles go around the curve.

- Along Curve Force: this makes the particles travel along the length of the curve.

After some tweaking of the values on the Curve Force, I got a result that I liked.

I also colored the particles and gave them a sand look.

GROUND ROCKS

I used the same principle as for the particles above, but randomized some attributes like Orient, W, Variant, and Mass before going into the POP network.

After the sim, I used a Copy to Points node to instantiate some rocks onto these points.

GROUND FOG

I also used the same setup as for the particles and rocks to get started with this fog. Although I had to use a Trail node to create far more points. For that reason, I wanted to optimize this a bit, so I used a Camera Frustum to get rid of any particles that were outside of the camera view.

Then I used a VDB from Particles node to turn the points into a Fog VDB, which gave me a pretty uniform volume, so I decided to add some noise to it to give it a much nicer look.

I noised the density using the Volume Sample approach, where I sample the density from a Position that has a noise added to it, which generates really interesting-looking breakups on the volume.

RENDERING

I used Redshift for this project, and I wanted to try and have a bit more control over each pass, reason why I created different sets of lights for each pass, which allowed me to have full control over the look of the render before going into comp.

I created Redshift Proxies for heavy geometry and volumes like the Curly particles and the Vortex smoke.

I set each render node with the necessary AOVs to have control over their look in comp, some of these include Diffuse, Specular, Reflections, Refractions, and GI for geometry and Volume Lighting, Fog Tint, and Fog Emission for Volumes.

Setting up unique lights for each pass also gave me freedom when it came to creating the main light of the portal, as the only pass that really needed that was the particles pass.

COMPOSITING

The main issue I had while comping this was that the lights seemed a bit off. I realized I needed to make the scene light up once the portal appeared so that it feels connected as a whole.

To solve this, I created Grade nodes for the environment and linked them to a Grade on the Portal that controls the intensity of the Portal's light, so that when that main light comes in, the environment lights up and gives that sense of connection between all the parts of the shot.

In this shot, I could use this AutoFlare script, which was very useful to create a nice Lens Flare once the main portal light appears.

As usual, I added some chromatic aberration, grain, and camera shake to give the shot its final touch.

CAR EXPLOSION

I started this project to see how far I could push myself in terms of volume effects and, to make it a bit more interesting, I added some RBD with cars to practice the workflow needed to produce a shot with different types of effects in context.

NOTE: this project is not quite finished yet, but it's in a good place to be shared.

CARS ANIMATIONS

I knew I wanted to animate the cars using Bullet, so I first prepared the model, ensuring each section was named accordingly.

I used the same model for the two cars in the shot and I knew I didn't need to do any fracturing because I only needed them to be animated. So I used a Convex Decomposition node to turn its complex shape into bullet-friendly pieces.

On the first car, I used Glue Constraints to keep the body together at all times, but for the second car, I used Soft Constraints as those give the best results when it comes to metal bending.

Once I was done with the simulation, I transferred the transformation information to the detail geometry that I didn't sim, so that they move with the rest of the car.

CAR RIG

In addition to the constraints that would hold the car together, I also had to create constraints that would allow it to drive. So I created duplicate objects of the tires that I used as helper geometry to create the constraints that connected the tires with the rest of the car.

Inside Bullet, I used a mixture of constraint types to simulate the car's suspension.

I used Soft Constraints together with Slider Constraints to allow the tires to move on the vertical axis, which mimics suspension.

I also used Cone Twist Constraints to allow the tires to rotate only on the axis that made sense for them, as tires don't rotate around all their axes.

I tried to use another set of Cone Twist to allow the car to steer, but it was giving some weird results, so I ended up disabling their influence.

I also tried to use Hard Constraints to add a Motor to the constraints on the tires, but it was also giving some unstable results, so to get the car to move, I ended up just giving it some initial velocity that would push it forward.

I wasn't looking to get any complex movement at this stage, so a straight trajectory was good enough.

ENVIRONMENT

I used Houdini's Heightfield tools to build the terrain for my environment. However, I faced a problem, I liked what the environment looked like in general, but the displacement was too much for the cars. So I decided to boolean out a section of the terrain to create a new surface with smaller features where my cars could drive safely.

This section alone is what I used in Bullet as the ground for my cars, so I had to Voronoi Fracture it to keep all its details inside DOPs.

Now I faced another problem, I had to find a way to merge the Heightfield with my new car's terrain.

I grouped some points on the heightfield that were on the edges of the boolean; these would be the points that would deform and blend into new positions to match with the new terrain.

Then I used VEX to create an array of close points on the new terrain and made an average of their Positions using a For Each loop, the result from this average would then become the new target position for the Heightfield points.

To blend between the original Position and these new positions, I decided to use a lerp() function, but I needed a bias value to drive it. So I used an xyzdist() function to get the distance to the closest point on the new terrain and fitted that into a 0-1 range that I then used as a bias to drive the blending of the heightfield with the new terrain.

One final detail that I wanted to add to the terrain was some displacement trails left behind by the car's tires.

To achieve this, I used a Solver where I displaced the terrain's geometry that was inside the tires. To get this information, I converted the tires into SDFs and used the volumesample() function to check whether the points were inside or outside the volume.

Then it was just a matter of tweaking the amount of displacement, I even added a ramp to control the smoothness of it depending on how much inside the tire the point was.

CAR DESTRUCTION

I brought in the car animation I made in Bullet and prepared it to be destroyed, for which the first step is to bring the geometry back to its rest position, so I did that with the help of matrices.

I split the geometry into its main components depending on whether I needed to fracture them or not and created a copy of their initial main attribute so that the new pieces are aware of where they belong, this will also be useful after the sim when I use a Point Deform to displace the geometry.

Before fracturing the main body of the car, I had to remesh it to create a new body that could actually be deformed as the original geometry didn't have enough subdivisions for that purpose. I turned geometry into a volume and back to polygons, which gave me the best result in this case.

With this new body, I could now fracture it using Voronoi Fracture. I am controlling the amount of pieces based on the volume of the piece that is being fractured, so that if it's a larger piece, then it will be fractured into many more pieces than the smaller ones.

Once I was done with fracturing, I merged all of the car components and applied the animation back with the help of matrices.

In terms of constraints, the main ones are Soft Constraints for the car fracture because they allow metal-bending behavior, which I need for the car to be dented.

I also created Glue Constraints between the main parts of the car components so that they don't just fly off after impact, but rather stay together and bend.

As I had loads of constraints, I decided to calculate restlength after all of them were set so that I could be sure that I was not overwriting it anywhere.

Inside DOPs, it's a very straightforward setup with the car and its constraints, as well as the ground and the impact object that would cause the car to explode.

After some testing, I decided to use frame 96 as the beginning of the sim, so I had to make sure that my pieces were set to Animated for all the previous frames. I managed to do this by simply setting the animated attribute to be the complement of the active attribute.

As for my impact object, I used a sphere that grows in scale to literally hit my car and make it fly away. It took some testing and tweaking to get a behavior I liked, I spent quite some time changing the sphere's size and position until I got a result that looked nice.

Once I had my sim ready, I retargeted the simmed points to my proxy car by using a Transform Pieces node, and then I used this proxy to deform the high-resolution car using the Point Deform node.

I used the attribute I set up during the preparation of the car as the Piece Attribute on this node to make sure that the pieces could recognize where they belonged and I could avoid weird deformations on my car.

CAR FIRE

I used the capot of the destroyed car as an emitter to make a quick fire simulation that would take place after the main impact and explosion. This was a nice detail to add as it was coherent with what happens during the shot.

TIRE DUST TRAIL

At first, I wasn't so sure about how to tackle this effect as it was my first time doing it, but after some research, I ended up making a particle simulation that would then serve as my source for smoke.

So I used the tires from my destroyed car simulation as emitters for my particles, I limited the emission to only the section of the tires that's closer to the ground so that I wouldn't get smoke coming from all the wheels.

Then I added some velocity vectors pointing in the direction that I wanted them to go and gave them some noise to add nice breakups and took that into POPs.

Once I had my particle simulation ready, I created the attributes I needed for my smoke sim: Density, Temperature, and Pscale. All of them are based on a ramp driven by the normalized age of my particles so that I can control when I get more smoke and when I want less.

I rasterized these attributes to turn them into volume fields and brought in a volumetric version of the wheels too to serve as colliders for the smoke.

For this simulation, I played with the Microsolvers until I got some nice results, mainly the Turbulence, Wind, and Dissipation as these controlled the main shape of the smoke sim.

Also, this simulation isn't made in static mode, it's made with the motion from the car simulation, which gave me some trouble in terms of the domain and the size of the simulation. So what I ended up doing was setting the Z boundary to $F - 1, which ensured that in every frame the domain would move according to the main animation and I wouldn't get an insanely large domain.

Once I had this simulation ready, I applied the same principles to the other car.

CAR EXPLOSION

For the source of the explosion, I decided to use a Vellum Grains emitter. I started with a sphere and added some noise to it, this noise already gives the sphere an explosion-like look.

Then I turned this into grains and assigned a velocity attribute that's equivalent to the positions so that when the points fly away, they maintain a similar shape to the noised sphere.

Once I had my grains sim ready, I did some more prep work before turning them into volumes.

First, I trailed the points and turned them into curves, to which I assigned the density and temperature attributes. I also duplicated this and tweaked it a bit to have longer curves that would then get assigned the pump attribute, which would affect the simulation for longer.

Then I rasterized these attributes as well as the velocity coming from the grains simulation to get them ready for DOPs.

Inside DOPs, I brought in my sources and decreased the influence of the velocities to avoid getting mushroom shapes.

Then I applied Microsolvers to drive the shape of the smoke, mainly turbulence to produce larger and smaller features. 

I also added a Gas Vortex Confinement to specify the bounds of the sim and make sure that the simulation only happens where it's visible to the camera.

I added some divergence from the density field that would only happen on the first few frames of the sim so that it expands only when the main hit occurs.

Once I was happy with my explosion, I made some post-sim adjustments.

The first one was to fade out the temperature field with a ramp so that it's only visible when the impact happens and not during the whole explosion as it's more of a smoke explosion.

I wanted to have full control over the look of the simulation post-sim. So I applied the knowledge from Urban Bradesko's tutorials.

First, I remapped the density so that I could have full control of how dense the explosion looked and even modified it with a ramp.

Then, I created a clamped version of the sim that was sharpened thanks to the Volume Convolve node and blended between the two versions with a lerp() function. This allows me to control how much sharpness I want on the smoke.

Finally, I made a multiplier for the density to control the overall look of the smoke.

All this allowed me to have full control over what my sim looked like.

SHOCKWAVE

In this case, I wanted to try using the tools that Houdini provides to make explosions, so I used the Pyro Burst Source to make my shockwave.

I added some noise to it to avoid uniformity both in the distribution of the points and their velocities.

Then I rasterized the volume attributes and took that to DOPs.

Inside DOPs, I used a simple Smoke Solver. I set my boundaries to be equal to a box I created in SOPs based on where the camera was and added Microsolvers to give nice shapes to the smoke.

I also added the car as a collision volume to have that interaction when the car goes through the smoke.

Finally, I added the same wrangles to control the density as for the explosion.

MISSILE

For the missile, I did something similar to the tire dust, I started with a particle simulation made from a noised sphere that I attached to the back of the missile geometry, and that I later used as a geometry light.

Then I used these points as my emitters for the smoke, I added the density attribute and gave it some noise using VOPs.

I didn't want this smoke simulation to have loads of details because it's quite far from the camera and doesn't need them.

CHARACTERS

I downloaded a Swat soldier from Mixamo with a driving animation, which I imported and used a Copy to Points node to make it move with the motion of the car. For that matter, I isolated a piece from the car and packed it to turn it into one point.

RENDERING

For this project, I wanted to be as organized as I could, so I used a color code.

Green nodes are prep nodes, where I imported geometry and got it ready for other processes. Purple nodes are reference nodes where I tested the timing of the shot with primitive objects. Blue nodes are where all the simulations and main FX are happening. Brown nodes are where I made Redshift Proxies for those FX that required it and Red nodes are the ones that are being rendered by Redshift.

I also resampled all the volumes (explosion, tire dust, shockwave) to use them on the render passes where I need them as Phantom. This reduced the render times significantly, although the shadows they produced weren't as accurate, which is to be expected because of the lower resolution, but the time optimization makes it worth it.

COMPOSITING

Compositing for this shot was pretty straightforward. I brought in all my render passes, split them into their AOVs, and then did a general color correction to give it this yellowy tint, very desert-looking. I added Motion Blur nodes to some of the smoke (mainly the tire dust) because it sometimes gets way too close to the camera and the voxels were a bit visible.

The camera shake was also very helpful as it helped me give the shot a more dynamic look.