FX Artist JJ Sun has shared a comprehensive breakdown of her recent Hurricane Simulation project, explained how the destructible building was set up, discussed the environmental effects, and showed how the simulation was rendered in Houdini Solaris using the USD pipeline.
In case you missed it
You may find these articles interesting
Hi there! My name is JJ Sun, and I'm an FX Artist who graduated from Lost Boys School of Visual Effects and going to start my career at Industrial Light & Magic in March. I have created a Hurricane simulation using Houdini, which I'm excited to share with you all.
My passion for art and technology started early on, but I studied finance and accounting at university instead. I spent several years working as a financial analyst, but my love for art never faded. I attended art school in the evenings and weekends to hone my skills in fine art, illustration, character design, and landscape concept art. Three years ago, I finally took the leap and became a full-time artist.
Before transitioning to technical art and visual effects, I worked as a freelance artist, creating illustrations, designs, and commissioned paintings. While I enjoyed it, I was eager for new challenges and opportunities to work with a team. That's when I ventured into technical art.
For the Hurricane Simulation project, I handled everything from modeling to lighting, effects simulation, rendering, and compositing. I'm excited to share my experience and a detailed breakdown of the project with you.
Getting Into Houdini
I first learned about Houdini from my friend, Kobi Moldavski, a Senior Environment Artist at DNEG. He suggested I look into Houdini and recommended the FXTD program at the Lost Boys School of Visual Effects. I was immediately intrigued by what Houdini could do.
So, I enrolled in the program in March 2022 and threw myself into my studies. I worked extra hard to catch up. With the mentorship from my instructor, Kyle Yoneda, the support from my schoolmates, the resources provided by the school, as well as the contributions of online Houdini content creators, I have gained the confidence to create virtually anything I set my mind to.
The Goal of the Hurricane Simulation
The hurricane simulation was my pitched project for the RBD (Rigid Body Dynamics) section of our learning module at school.
My main goal for this project was to recreate a scene based on a real-life hurricane scene as accurately as possible within the six-week timeframe. I used footage from the Tornado Trackers of Category 5 Hurricane Michael hitting Panama City Beach as my reference. My focus wasn't on creating a cinematic shot but on honing our attention to detail and ability to create a realistic simulation.
To create a cohesive wind-storm effect across all elements, I worked with references extensively. I paid attention to the motion of debris and the interaction between the wind and the surrounding environment to ensure that my simulation was as realistic as possible. I also explored the interaction between the RBD bullet solver, Vellum, and PYRO, which allowed me to create a more dynamic and seamless simulation.
Stage I: Research and Planning
To ensure a smooth workflow, I always begin a project with research and planning. This involves creating a work plan that outlines my approach to the project and estimates the timeline, which I revise regularly. I find it not only helps me stay organized but also serves as a snapshot of my progress during our weekly screenings with my supervisors.
As the project progresses, I may need to adjust my plan to account for any changes. You can see an example of my work plan below:
- Week 1 Reference Analysis, Research, and Planning
- Week 2 Modeling & Fracturing
- Week 3 RBD Simulations
- Week 4 Vellum Simulations
- Week 5 Pyro Simulation and Test Render
- Week 6 Final Render
Some Useful Tips for Reference Analysis and Planning
When I start a new project, I like to convert the reference footage into image sequences and use them as backgrounds in my 3D camera. This method makes it easy for me to compare my simulation with the reference.
To keep things simple, I focus on the most important elements of the scene and break them down into static and dynamic parts. For instance, when I was working on the hurricane simulation, I only needed to fracture the camera-facing sections since those were the only visible parts of the house. To get a better sense of the final result, I create a quick pre-vis with simple animation and camera setup. This helps me visualize the timing and overall look of the shot before diving into the actual production.
Stage II: Modelling and Fracturing
Assets for destruction are usually custom-built, as there is a specific requirement for a model to be destruction-ready. For example, every piece must have a proper name attribute, and you need to make sure the geometry is closed (water-tight) and no open holes, wrong normals or unused points, etc.
1. Store User Input Data in a Master Controller Node
- I gather all the key measurements I can think of as if I were building a real house. To keep it procedural, I like to have all the user input data (such as the length, width, wall thickness, etc.) linked to one custom Master Controller node. So I can easily adjust the parameters in one place without going through the entire node network. And this will make it easier to convert to HDA if I decide to make it into a house generator later.
- One unit on the Houdini grid is equivalent to one meter. So I try to set up my house using the real-world size in the Houdini unit. This is very important if you want to create physically accurate simulations.
2. Make a Low-Res Block Shape and Match it with the Reference
- I then create a low res block shape and put it into the reference background to check if it matches.
- All the measurements on the low res model are linked to the master controller.
- I then used the low res block as a template and a boolean object to construct the detail house.
3. Construct Detail Model
- I referenced a variety of house construction plans and simplified them to what I will need for the shot.
- The most important thing for building models for destruction is in the "name". I used the Assemble node after each group to give the proper name to each piece.
In order for the RBD bullet solver to work, I needed to make sure there is no intersection between those pieces that will be simulated. Here are some useful tips to prevent intersection:
- The Matchsize node is extremely useful when making RBD-ready models, as I can specify how each piece is aligned and I always leave a 0.001 gap among each piece to ensure there is no overlap.
- I also used the Intersection Analysis node to help check intersections and used the Group node to check unshared edges to ensure every piece is water-tight.
4. RBD Fracturing, Constraints, and Custom Clustering
- Once the model is ready, the next step is to fracture the parts that will need to break.
- Since only the roof and parts facing the camera will be seen, I first separated out the part that does not require fracturing to simplify my workflow.
- Then I split out each named group and fractured them individually before packing them together.
- For the fracturing, I used both my custom fracturing tool and the RBD material fracture node.
- Then I optimized the fracturing geo by removing small pieces and inside pieces.
- To make the destruction more interesting, I clumped some trunks together, so they are not all breaking at the same time. By using the clustering method, I can specify weak, medium, and strong glue constraints which will break upon different levels of impact. For example, when the wind first blows the roof off, only the small pieces at the edge are breaking off, and the entire roof is still in tack until it collides with the background houses.
- Finally, I run a quick simulation to make sure everything is working correctly before moving on to the next stage.
Stage III: Multi-Stage RBD Simulations
- To break down a complex destruction shot into stages, here are my steps:
- Determine which materials have no interactions and can be simulated separately.
- Analyze the dependencies between different simulations to determine the order in which they should be done.
- Break down the shot into manageable stages and tackle each stage separately.
- Test each stage thoroughly before moving on to the next one.
- Once all stages are complete, bring them together in the final shot.
By using multi-stage simulations, I can avoid overwhelming myself with a complex simulation and make the process more manageable. It also gave me more control over art direction at each stage.
For instance, let's say you have a shot where a building is collapsing, and there are several types of materials involved such as glass, concrete, and steel. Instead of trying to simulate everything at once, you can break it down into stages. First, simulate the concrete and steel collapsing together, as they are more structurally related. Then you can simulate the glass breaking and falling to the ground separately from the concrete and steel. Finally, you can bring all the elements together and simulate the interaction between the glass, concrete, and steel.
In my Hurricane project, the roof, loft boards, and pink insulation all can be simulated separately, as they had different interactions with each other. By breaking it down into stages and simulating each component separately, I was able to better manage the complexity of the simulation and achieve the desired results.
Stage IV: Environmental Wind-Storm Effects
Most of the wind-storm effects in the scene were created by applying motion to the environment elements such as the roof cloths, cables, palm trees, and grass. I used Vellum Solver in Houdini to simulate all these. The wind force was created using the pop force node inside the DOP network. While there are many details involved in setting up Vellum simulations, it may be too lengthy to discuss here, so notify me if you would be interested in hearing more about the topic.
In the final step, I added atmospheric dust and volume to the scene. To achieve this, I created a custom velocity field and ran a pyro simulation using the sparse solver. This helped me achieve a realistic look for the dust and smoke in the scene and added depth to the overall atmosphere.
Stage V: Final Render in Houdini Solaris using USD Pipeline
My final render was done in the Houdini Solaris LOP network. I converted all static elements to USD and directly referenced them into Solaris, using SOP import to bring in all the vellum and volume elements. I set up lighting and camera and rendered out AOV passes using Houdini's native Karma render. I also used point instancing for all the RBD dynamic elements directly inside the Solaris LOP network. Using the instancer method allowed me to store position, rotation, and velocity data on points and apply them to static RBD fractured pieces at render time, which significantly reduced render time. Then, a final touch-up in Nuke for minor color correction and camera shake.
Tips and Tricks
If you're setting up a similar simulation, here are some tips to keep in mind:
- Research and analyze your reference footage to better understand the key elements you need to create.
- Create a project plan that breaks down the simulation into manageable components.
- Spend time preparing a good model with a unique "name" attribute for each fractured piece will make your simulation process much smoother.
- Focus on getting the big motion right before layering in details.
- Do the hard surface destruction first, then move on to soft body simulations.
- Always keep the final image in mind to focus your time on what matters the most.
- Use point instancing to store position, rotation, and velocity data on points and apply it to static RBD fractured pieces at render time to significantly reduce rendering time.
- Keep in mind that production workflows can be iterative and involve several rounds of refining, rendering, and feedback before the final shot is approved.
Resources for Beginners
- SideFX Documentation: The fastest way to learn a new node is to click on the help icon on Houdini and read the documentation.
- SideFX Tutorials: Rohan Dalvi's introduction series on the SideFX website covers the basics and provides useful functions that helped me to get started.
- SideFX Content Library: The content library includes many example files, including all the .hip files for its new pyro demo such as the atomic bomb and sexy fire.
- CGwiki: Matt Estela explains concepts really well and provides very helpful gifs with his demo, and you can download his .hip files to see his setup. The "Joy of VEX" is probably the best introduction to VEX.
- Entagma: Moritz and Manuel have a great range of content for beginners and advanced Houdini users. Their beginner-focused content including the Vellum 101 and Particles Series are my favorites.
Other great online Houdini content creators such as Rebelway, Adrien Lambert, John Kunz, Junichiro Horikawa, Paul Esteves, Keith Kamholz, and many more. I greatly appreciate them for their contribution to the tech art community and wish to do the same!
Feel free to connect with me on LinkedIn or Instagram for further feedback. Thank you for reading!