|On this page|
Houdini is an advanced procedural modeling, animation, effects, simulation, rendering, and compositing package.
Houdini’s power is based on procedural workflows. Working in Houdini involves creating networks of nodes connected together that describe the steps to accomplish a task. For example, a node that creates a box might be wired into a node that extrudes the sides of the box, then a node that subdivides the polygons, then a node that edits the point positions. This gives you tremendous power:
You can go back to previous nodes in the network and change selections, change settings, or swap out assets. The changes automatically propagate through the network to change the final result. You never have to undo or start over and recreate your work to change a decision you made earlier.
It encourages rapid prototyping. You don’t have to throw away work you do while exploring ideas - just reuse parts of the network or reconfigure the network to upgrade it to production quality.
Because Houdini is based on generating things procedurally, it has a lot of tools for managing extremely large and complex scenes, including support for generating/loading geometry, and adding detail at render time instead of keeping everything in memory.
You can package up networks and make them into new tools with their own interfaces without having to write any code. In Houdini, these tools are called digital assets.
Nodes and networks
Houdini lets you work in a 3D view using the shelf tools without having to worry about nodes and networks. However, an understanding of networks is essential for getting the most out of Houdini.
Houdini’s networks are like a computer’s file system, where networks are like folders and nodes are like files. Nodes can also be subnetworks that contain other nodes. Below is an example of a network of nodes.
Houdini’s root network contains a few pre-made networks like the object or “scene” level network (
/obj) and the render node network (
/out). Networks have a “type” (such as “geometry network” or “dynamics network”), which determines the types of nodes you can put in the network.
The object level network (
/obj) contains the “top-level” objects of your scene (geometry objects, lights, cameras) and lets you set up relationships between the different objects. At the object level, you can have objects that are purely subnetworks, such as geometry subnetworks that contain nodes that define an object’s geometry (cube and grid in the example below) or dynamics subnetworks that contain nodes that define the behavior of a simulation (dopnet below).
Within the cube geometry subnetwork are nodes that define the cube’s geometry. The geometry level is one level below the object level.
This two-level design is different from other packages such as Maya and 3D Studio Max where all the nodes live at one level.
Houdini’s user interface is divided into different types of panes, such as the 3D scene viewer, the network editor, and the parameter editor. Each pane can focus on a different network, but by default they are all set up to follow the same network.
Nodes have inputs and outputs. You create relationships between nodes by wiring the output of one node to the input of another.
Wiring can have different meanings in different network types. Usually it means that the data created or processed by one node is passed to the next node. However, at the object level, wiring object nodes establishes hierarchical or parenting relationships between the objects.
Each node has a user interface of settings called parameters. You can edit these parameters in the parameter editor pane to change the function of the node. Below is an example of the parameters shown in the parameter editor for the Crowd Solver node.
Geometry and attributes
Houdini supports different types of geometry, such as polygons, NURBS and Bézier curves, geometric primitives such as circles and spheres, and metaballs. Houdini refers to each “piece” of geometry of any of these types as a primitive. For example, a polygon face is a primitive, a polygonal curve is a primitive, and a metaball is a primitive. This is less-than-ideal terminology, because some “primitives” have editable components. For example, polygon faces have points and vertices.
Much of the information that makes up a scene is stored in attributes - hidden data stored on models, primitives, points, and vertices. For example, Houdini displays points at the position in space defined by their
P (position) attribute.
You can view the geometry attribute values in Houdini using the geometry spreadsheet.
You can also visualize attributes using visualizers.