Houdini FX Tool Building Foundation

Taught by Robert Thomas

Course Number:
Software Version:
Original Run Date:
October 2019 
4 hours 43 minutes 
This introductory level offering aims to get you started with a solid base of the foundations of tool building, showing how to create a complex Houdini file so that it can be run in dozens or even hundreds of shots with minimal effort in a pipeline. The course is primarily focused on a Houdini concept called OTLs, which is a way to build our own nodes out of other nodes. To that end, the course starts by making an object-level node that automatically generates emission geo from any arbitrary camera.

We'll show how to provide hooks to users so that they can customize parts of the setup, how to create custom viewport handles, and how to improve the setup by finding inefficiencies and fixing them. We'll use Python to control Houdini on a deep level with the OTL's HDAModule, as well as looking at how to leverage various specially named scripts to further customize how Houdini treats our new node types.

There's nothing quite like being given several dozen shots to do and watching your lead's eyes widen when you have a compelling first version ready for each of them by the next morning. By the end of this course, you'll be well on your way to creating the kinds of setups that let you do just that.

Robert Thomas studied visual effects at the University of Texas, Dallas, where he took two semesters of Houdini and fell in love. His passion for Houdini and effects work blossomed during an internship with Side Effects, and 6 months later he landed his dream job at Digital Domain working on the Roland Emmerich film 2012. During his 10+ years at Digital Domain, Robby was attracted to tasks where he could build Houdini setups for other artists, and support those artists, solving any technical issues along the way.
Houdini FX Tool Building Foundation
Watch our overview of the course

Class Listing

Class 1: Introduction to OTLs

Introducing OTLs, Houdini's answer to copy/pasting large networks dozens or hundreds of times. We'll use this concept to make a tool that automatically creates an emitter based on any arbitrary camera.

Class 2: Managing OTLs

Now that we've gotten our beaks wet looking at how to create an OTL, we'll dive in and look at how to manage them, including manual installation, copying/renaming, and manual uninstallation.

Class 3: Best Practices

Use our newfound understanding of the power of OTLs to discuss various best practices concerning their creation. We'll contrast the One Big OTL theory against the idea of making several, more modular OTLs, discussing the pros and cons of each. We'll also cover what some of the pitfalls are of using OTLs for beginners and how to avoid them.

Class 4: Converting Setups to OTLs

What if we're given a setup and asked to convert it to OTLs? This is what we'll mostly spend the class doing. In this video, I pretend I've never seen the tentacles setup before and cover some techniques for how to read a relatively complex setup. While running through things and trying to understand them, we'll also strategize how to organize the setup to make it easier to convert to OTLs.

Class 5: Making using OTLs easier

It's a pain to manually install our OTLs every time we launch Houdini. Let's look at how to leverage the HOUDINI_OTLSCAN_PATH environment variable to automate this process. Also introduces the Houdini Command Line Tools app for Windows, and how to use the hconfig -a command to see what environment variables we can set.

Class 6: Starting the Tentacles Setup

Set up the Create Lines OTL, the first OTL in the tentacles setup. For this OTL, we'll cover how to add custom viewport handles to our node, and how to provide a part of the OTL that users are meant to modify so that they don't have to unlock our node in order to do so.

Class 7: Naming Conventions

There's a better naming convention that SESI provides for OTL type names. We'll explore how it works, and how to leverage it to create our own default node naming convention.

Class 8: Outputs

Getting the output of an object-level OTL is something we're doing a lot in this series. In this video, we'll explore how to standardize that using a custom expression function and how to avoid having to deal with hscript too much.

Class 9: Stick to Collisions OTL

Set up Stick to Collisions OTL. With this node, we're concerned with how to display the node's complex operation to the user in such a way that they can easily see the effects of the changes they're making while tweaking the settings on the node's UI. We'll also discuss some strategies for how we can handle multi-parm blocks in a robust fashion.

Class 10: SOP-based OTL

We'd like our setup OTLs to be able to write each step to disk. Instead of copying nodes around, why not make a SOP-based OTL? While we're at it, we'll look at how to use guide geometry to compare versions, which is a feature that's only available in SOPs.

Class 11: Creating a self-extracting OTL

We've made a bunch of magnificent OTLs, but it's pretty painful to instantiate them into a new shot. For this video, we'll solve this problem handily by making a self-extracting OTL, and look at how to avoid some common pitfalls like making it difficult to modify (since the OTL deletes itself while extracting its contents when you put it down).

Class 12: PDG and Houdini TOPs

Introducing PDG and Houdini TOPs, a context that's new to Houdini 17. It's a powerful way to set up dependencies between tasks. We'll use it to robustly render the outputs of each of our OTLs in sequence, making sure that each frame waits for the appropriate parent frame or frames.