Creating Cracking Concrete Effect Using Houdini

Introduction

My name is Pol Villà and I'm a Senior FX Artist/TD at El Ranchito (Spain). I would be lying if I said I have a story with visual effects that started when I was a kid and I saw Star Wars or Jurassic Park for the first time, and ever since I set myself the goal of one day being working in such movies. But here's the thing, my path wasn't a direct one. I actually started off pursuing a physics career, driven by a deep curiosity to unravel the mysteries of the universe. I dedicated several years to it, but eventually, I realized that my true passion lay in visual effects. It was the perfect blend of my love for mathematics, physics, and the art of storytelling. But there is something that inspired me though, the Levi’s Odyssey advert that was aired in 2002. In just one minute, they managed to capture so much passion, drama, and pure magic. Seriously, you've got to check out the VFX breakdown for that one, it's mind-blowing.

I began my journey by studying general CGI in Barcelona, but it was when I first opened Houdini that I fell in love with its immense potential. From that point on, I immersed myself in solving various personal projects and repeatedly replicating setups and methods until I became self-sufficient. The process of troubleshooting and finding solutions is incredibly fulfilling, and it's a feeling I continue to enjoy.

Throughout my career in visual effects, I've had the opportunity to contribute to numerous projects, including feature films, TV shows, game cinematics, and even a museum project for the 2020 Dubai Expo. Some notable projects I've worked on include Avatar: The Way of Water, Transformers: Rise of the Beasts, Black Adam, Star Trek Discovery, Colony, Krypton, The Girl in the Mirror, and many more.

Houdini

Learning Houdini was part of my study plans, and although I hadn't heard of it before, I had a feeling there must be a powerful software out there capable of handling complex effects like destruction, smoke, water, particles, and more. My expectations were quickly surpassed when I began to grasp the power of the procedural workflows in Houdini. This discovery greatly motivated me, as I realized that Houdini offered limitless possibilities. What excited me even more was that every new aspect or technique I learned didn't just add to my skill set, but multiplied the possibilities exponentially. Houdini turned out to be a delightful, robust, fast, and fun tool to work with.

However, the key to mastering the software was the process of trial and error. I faced numerous failures in my projects, but I refused to give up. Instead, I embraced these challenges and focused on understanding and gradually incorporating new workflows, techniques, code, and setups to bring my ideas to life. This approach helped me immensely in developing a deep understanding of Houdini. It taught me the logic behind its functionalities and allowed me to create the effects I had in mind.

The Cracking Concrete Effect

The cracking concrete effect wasn't originally my idea. While working in production, I also assisted students at Animum School with their projects. Igor Galdona, an incredibly talented student who by the way is seeking a role in the industry, approached me for tips on creating a cracking concrete effect inspired by the movie Encanto. After seeing a brief breakdown of the process on SideFX’s website, which involved pushing each piece of the chunk to create the cracks, I was motivated to take on the challenge. However, the process turned out to be more complex than anticipated.

There was no formal pipeline for my procedural setup. I approached it by coming up with ideas, testing them, checking the results, and refining or adding new elements as needed. I started with a simple box and aimed to generate a cracking effect based on a line that anyone could draw. To demonstrate its procedural nature, I created a PDG (Procedural Dependency Graph) wedging setup, allowing me to generate four different types of fracturing without modifying the setup.

In terms of tools, I primarily relied on Houdini's built-in features. However, when it came to sourcing volumes, I decided to use the Axiom Solver due to its speed and ease of use. Additionally, I utilized a custom digital asset I created to generate quick wedges, which is available for free download.

It's important to understand that starting a setup with a fixed idea and progressing without changing the approach multiple times is uncommon. The strength of Houdini lies in its flexibility, allowing artists to make adjustments at any stage of the process. For instance, I could be working on the final layer of my setup and realize that something from the beginning is affecting the dust simulation, prompting me to revisit and modify earlier stages.

Let's briefly discuss my setup. As an artist, I prefer having attributes visible, so I created a script assigned to a shortcut that selects all integer and float attributes from a list and creates a color node to visualize them. This explains why there are numerous attributes in my scene. That’s why you see so many of them in my scene.

The initial line comes from a "Draw Curve" SOP, which provides useful attributes like @stroke_time and @index. After refining the line through operations such as fuse, resample, and deleting @stroke_hit==0, I perform a ray projection onto the wall and use a wrangle to animate the curve based on a custom ramp. In this wrangle, I utilize inherited attributes like index, max_index, and @curveu to generate the animation. Additionally, there is another wrangle for cases when the drawn line consists of only one stroke.

Once the curve is ready, I generate an extruded version to cut the wall. In the latest versions of my setup, I also use the curve to remesh the wall based on the distance to the line, providing higher resolution on closer points.

To create the cut on the wall, I use a cutting surface on a simple fractured wall. This allows me to generate pieces that share edges with the cutting geometry, which facilitates future steps. It can be challenging to have pieces in the cutting surface area, and having too much resolution in the initial fracture can make later steps heavy to compute. To address this, I replicate some points using the first and last values of the @curveu attribute and add them to the input points of the "RBD material fracture" node.

Next, I generate space between the pieces using a method similar to what I believe was used in the movie Encanto. For each piece, I create a "scale" attribute based on a float noise, convert the piece to VDB, perform erosion, convert it back to polygons, and then cast the original piece into the eroded one, but only for the interior group. The "scale" attribute adds randomness to the process.

After the loop, you should have the desired result. The resolution values in the VDB and erosion operations are important factors to consider.

Since I saved a “rest” attribute before the erosion operation, I can store the eroded geometry in a new attribute called "v@pos2" and return to the rest position by setting v@P = v@rest.

Moving forward, I import the growing curve, initialize a "@mask" attribute on both geometries, introduce some variation in the "@pscale" attribute of the curve, polywire it, and transfer the mask attribute I’ll use to create the crack.

To do so, I’ll simply use a linear interpolation function in a wrangle, like this: v@P = lerp(v@P, v@pos2, f@mask); 

That’s pretty much it! There are some extra steps to make it look even prettier but the main theory is what I just told you.

Now, the next steps involve creating RBDs (Rigid Body Dynamics) on the pieces intersected by the line and bending the closer pieces to simulate the effect of the crack.

To begin, we need to generate another fracture. Prior to that, I create a "moving" group by comparing the positions of points in the first and last frames. This setup involves several steps that I discovered were necessary at different stages of completion. The key objective here is to avoid the Voronoi look at all costs. While our crack method produces intricate details in the line area, it also introduces a problem: non-manifold geometry resulting from the boolean crack operation. This can cause issues when adding detail with "RBD material fracture". To address this, I implemented a feedback loop that attempts to fracture the geometry while adding details only if valid areas are present. In each iteration (up to a maximum of 15), the seed and number of scatter points are varied in the hope of achieving a valid fracture. If non-manifold geometry persists after 15 iterations (detected through an edge group of unshared edges), a basic "RBD material fracture" is used to ensure valid fracturing. Additional detail is added later in the shader.

Once again, we transfer a mask attribute from the curve and create the crack on our newly fractured geometry using the "moving" group and a linear interpolation wrangle.

Now, at this specific step, I need to create UVs and add interior detail for future mesh shading.

Great! It's time to pack the geometry, initialize @active and @deforming based on the mask, and create the rotation of the pieces using a custom wrangle.

Take note of the control I have over the rotation angle by utilizing custom attributes such as @vs, @mask, @area, and another noise called @_mask. The @vs attribute comes from the volume sampling of the curve.

Once the rotation is set, it's time to generate an active attribute based on the mask of the curve. Some noise and distance limits to the curve are applied, along with initial velocity, and now we can start the simulation! To prevent the pieces from going behind the wall, I created a box of the same size and placed it behind as a collision object.

Nice! Now we can save our RBD points to disk, load them, and apply transform pieces to our deformed geometry. It's crucial that this geometry includes the animation of the wall crack and the deforming pieces.

That summarizes the rigid body process!

If you've made it this far, the rest is easy! To generate debris, we blast everything except the interior faces, create a growing age attribute based on the mask using a solver, and delete everything except the geometry aged between 2 and 4 that is close to the curve (again, we transfer a mask attribute).

We can also transfer the active attribute and generate a scatter based on it. We add some random velocity and random bounce and then pass it to a pop network. The simulation here is quite basic, with some drag forces based on the inherited @pscale.

To instance random pieces onto these points, we fracture a geometry (no need to add detail) and use a basic method to create a random @index on our particles within the range of 0 and the number of pieces in the fractured geometry. Then, we use a blast and the iteration value in metadata to remove everything except the @index that matches our current iteration. And there we go, our debris is done!

Finally, to generate the smoke or dust, I start by creating some sources from different elements.

On one hand, I create a density attribute based on the distance from the first and last frame of the crack in the wall (the more separation it has, the more points will emit). I add some random life to them and create a particle simulation just to have smoke right at the crack of the wall. We don't need gravity here, just some disturbance of the dust.

Then, I use a Debris Source SOP to generate debris from my RBD (using a proxy, not high-resolution geometry). Lastly, I use my debris points to generate more smoke. I combine all these sources, add some random velocity and necessary attributes, rasterize the points with some velocity blur, add some noise to the volume using the Volume Noise Fog SOP, and voila! We can plug this into the Axiom Solver and start the quick simulation. Remember to add a ground and perhaps the wall behind.

I found some artifacts on the density field so I ended up clamping the density value before sending the sim to the next steps.

Rendering

To set up the final renders, I started by finding a nice wall texture on Textures.com and applied it to the exterior group of my wall.

To have fine detail on my geometry, I first created a vector attribute in SOPs based on a noise projected onto the surface (tangent). I later used this noise attribute in my shader to add displacement.

I used a principle shader and added the inside shader with another texture that had a brownish appearance. For the wall material, I used a material builder. Inside the material builder, I applied the wall texture and imported three attributes: @deep (coming from RBD Interior Detail), @disp_noise (vector), and @noise (float).

I used a mix node to blend the outside and inside noise based on the @deep attribute. I added this to @P, checked the current space using a transform, generated the displacement noise using a “Shading Normal”, and outputted the result.

In my render setup, I always create /obj nodes starting with REN_ to easily identify them. In this case, I had four of them: REN_SMOKE, REN_GEO, REN_DEBRIS, and REN_GROUND.

I assigned each material to the corresponding geometry, created basic lighting, and started performing render tests. To check my shaders, I created a second camera placed closer to the wall to verify if the displacement and other elements were working correctly.

To optimize the setup and reduce rendering time, I conducted several tests. I selected specific areas in the Mantra render tab and rendered a few frames. Then, I compared the results to see the level of noise or artifacts and made adjustments if necessary.

A tip I can give is to be patient during this process. Never underestimate the potential for a render to go wrong. It can be frustrating because you have already completed the most challenging parts. Make sure everything in your render is working fine by conducting tests for any potential issues. Test everything that you think could go wrong and try proxy renders with reduced resolution.

You might need to repeat the rendering process several times until you achieve the desired result, but it's worth it. Sometimes, you may need to refine or redo certain steps in your setup due to rendering issues.

Tips for Artists

The fact that some artists are willing to create similar effects is great! It means they have the initiative and a desire to prove themselves by studying, analyzing, and replicating natural phenomena or movie shots. When setting up similar effects, it's important to consider your skill level. Avoid spending too much time on a setup that may be beyond your current abilities. Instead, analyze how the effect could be achieved and assess whether it aligns with your skills. Be creative and think outside the box! Companies appreciate proactive individuals, and the community often supports new ideas shared on social networks, so your efforts may have a significant impact.

When it comes to learning Houdini, there are numerous resources available. Rather than providing a specific collection of courses and tutorials, I recommend learning on the fly through personal projects. Identify your needs and search for solutions in the Houdini documentation, forums, groups, YouTube, and other platforms. You'll learn a great deal through this process. 

Additionally, it's important to stay organized not only within your Houdini scenes but also in your collection of materials. Consider creating a folder on your operating system where you can store all the .hip files you've gathered throughout your career, sorted by categories such as destruction, smoke, water, VEX, PDG, Python, and more. This organizational approach can be highly beneficial. I hope these tips help you on your journey!

Pol Villà, Senior FX Artist

Interview conducted by Theodore McKenzie