Network types

Houdini organizes the operator nodes into hierarchical networks.

You can refer to nodes in the networks using paths like UNIX file paths that specify the location of the node within the hierarchy, for example /obj/model/sphere means the node named sphere inside the geometry (SOP) object named model at the object level (/obj).

Most network types have default paths (for example, objects usually live inside /obj), but you can create subnetworks of specific types inside other types of networks. For example, to do dynamics you create a DOP network node at the Object level. You can then create a Geometry (SOP) network node inside the DOP network to hold the simulation’s geometry. This technique comes in handy when you want to package up your networks as self-contained digital assets.

Network type Use Default path

Objects (OBJ)

Contains the “top-level” objects of your scene (geometry, skeletons, lights, cameras, microphones, fog) and lets you set up the spatial and hierarchical relationships between them.

The object level is where you position the characters, props, cameras, and lights in a scene. You model the actual surfaces that define skin/shape of the characters and props inside Geometry object nodes using SOPs (see below).

Network connections at the Object level create hierarchical (“parenting”) relationships.

/obj

Geometry (SOP)

A geometry network is contained within a node at the Object level. It holds the geometry operators (SOPs) that create the surfaces that give an object its shape.

You can also create geometry (SOP) networks inside other networks, such as dynamics (DOP) networks to hold any incidental geometry they use.

Network connections at the geometry level control the flow of data from “generator” nodes (that load or create new points, curves, surfaces, etc.) through filter nodes (that edit, combine, split, etc. the data) to create the final surfaces.

/obj/object_name

Particles (POP)

You can set up particle simulation networks at the /part level or inside Particle network nodes inside, for example, a geometry (SOP) network. For example, if the particle effect is part of or creates the look of an object, you would want to put it inside the geometry level. If the particle effect is part of the overall scene, you can put it at the /part level.

Network connections at the particle level control the flow of data from “generator” nodes (that create new particles) through filter and force nodes (that edit, combine, split, apply forces to, etc. the particles) to create the final particle simulation.

/part

Dynamics (DOP)

Contains dynamics operators (DOPs) that create or load objects and forces and establish the connections between them and configure solvers for simulating their interactions.

Houdini does not have a ready-made place to put dynamics operators, like /shop for shaders. Instead, like geometry, you must create a container DOP network node inside another network (such as at the object level) and then create DOPs inside the DOP network.

/dynamics

Shaders (SHOP)

Contains the shader nodes you create and configure to control the rendered appearance of surfaces.

Some Houdini shaders are hard-coded by the original author to create a particular look (although they may have many options for configuration). Other shaders, including all the shaders in the shader palette , are defined by VOP networks and you can configure them using their “public” options or edit their original node network “source code” if necessary.

The shader level does not generally require to connect nodes: each node represents a shader you can refer to in objects and surfaces. However you can connect shader nodes into switcher nodes that let you select between different shaders based on an expression .

/shop

VEX Builder (VOP)

Contains VEX network types (for example, surface shader, displacement shader) which in turn contain VEX operators (VOPs) you create and connect to define VEX or RIB programs. VOPs are a very generalized system for programming by connecting nodes, but they are generally used to create shaders .

At the VOP level you connect the outputs of functions to the “argument” inputs of other functions to build a program.

/vex

Motion and audio channel operators (CHOP)

Contains channel operators (CHOPs) for manipulating waveform data. This is mainly useful for procedurally creating and editing animation curves, but you can also use CHOPs to manipulate audio, and Houdini uses CHOPs to implement the kinematics solvers of characters.

Network connections at the CHOP level control the flow of data from “generator” nodes (that load or create new waveforms) through filter nodes (that edit, reshape, clip, etc. the waveforms) to create the final output.

/ch

Compositing (COP)

Contains compositing operators (COPs) for manipulating 2D pixelmap data. This is mainly useful for compositing images such as render passes, but you can also use COPs to manipulate and pixel-based data, such as shadow depth maps.

Network connections at the COP level control the flow of data from “generator” nodes (that load or create new images) through filter nodes (that edit, reshape, clip, etc. the waveforms) to create the final output.

/img

Render outputs (ROP)

Contains render outputs (ROPs) , which control output of composited and rendered images and animation. For example, you can control mantra and RenderMan output, the frame range to output, and the name(s) of the rendered image files.

The ROP level does not require to connect nodes: each node represents a renderer and configuration you can use to render the scene. However you can connect ROP nodes together to create dependency graphs , allowing you to define dependency relationships between render passes.

/out