Motion Design in Houdini with MOPs (Patreon)

We’ve talked a lot about the unique challenges of instancing, including understanding orientation with quaternions and randomizing attributes like size and color. Houdini is a powerful tool for creating instance setups and exporting those point clouds to other CG apps.

But, as always, working in Houdini is highly technical and many things that should be simple require multiple steps. It’s a tradeoff between ease of use and ultimate flexibility and Houdini always errs on the side of the latter.

This is where the very useful MOPs addon comes in. It’s a professionally-designed set of tools that form a wrapper around a lot of core Houdini functionality. MOPs was created by experienced CG artists Henry Foster and Moritz Schwind and exists in two editions: the free MOPs and a paid MOPs+ upgrade.

I’d go so far as to say that MOPs is required for happy Houdini usage. It streamlines some of the most common Houdini tasks and I find it useable in just about every type of project. MOPs+ is similarly great and adds even more features, including support for dynamics in DOPs.

To install MOPs, simply download it here. Extract the contents to a location of your choice (I put it under /plugins in my Houdini user folder). Then, put the .json package into your Houdini /packages folder and make sure it’s pointing to where you extracted the MOPs files.

(Note: I thought that inline images on Patreon were clickable to see the original size. They're not! I added links to most to enable viewing them at full resolution.)

Next time you run Houdini you’ll find a new MOPs menu in any /obj geometry context.

MOPs offers complete in-Houdini documentation and lots of example files. Let’s learn how it all works!

The core aim of MOPs is to provide a comprehensive toolset for creating copies/instances of objects and modifying their appearance and behavior. Central to it all is the mops_falloff attribute. This is essentially a mask that all MOPs nodes look for. Most MOPs tools are set up similarly and share similar parameters, making it easy to quickly know what’s going on as you add additional nodes to your scene.

Let’s create a basic MOPs setup to instance objects and control their attributes. Here I added some test geometry and used a Match Size node to, well, match their size.

I then connected them to a MOPs Instancer. This lets us create copies of any number of objects and control their distribution and many other attributes.

We can choose from many techniques for creating the points to copy our objects to. MOPs can generate point clouds on the fly, scatter new points onto an existing mesh, or use existing points. Here I scattered new points onto an existing Template Object (grid1) and set Force Total Count to 100 points. Note that the Template Object doesn’t have to be wired into anything else.

Our objects are pointing the wrong way, so we can adjust their Global Transform to fix that.

Now we can add a MOPs Randomize node. This is a powerful tool for controlling attributes on our point cloud.

Let’s randomize the size, position and orientation of each object. Simply check each box to open up a new set of parameters.

Note that we can also control the probability of each of our three objects appearing. By default they all have an equally likely chance, but it’s easy to change that using sliders in the MOPs Instancer. Let’s make our pig heads 75% less likely to appear. We can immediately see the result of the change.

Head on over the geometry spreadsheet and check out all the attributes that MOPs has created on our points.

We have a new orient quaternion, pscale for size, mops_index of 0, 1 or 2 for tagging which object appears on which point (note that 0 appears less frequently now that we decreased Pig Probability), and much more. All of these attributes can be accessed in any other app. For example, we could export this point cloud to Alembic and import it into Gaffer for final instancing and rendering (see my earlier article on this topic here).

I mentioned the mops_falloff attribute above. Let’s use MOPs falloff generation nodes to further control our setup. Falloffs are masks that usually range in value from 0 to 1 and have a controllable “falloff” that describes how gradually they transition from “on” to “off.” We can use all sorts of inputs to set up falloffs: built-in MOPs shapes, other objects, curves, painted attributes and more. Here are some examples of using various inputs to set up falloffs in our scene: Noise, Object, Texture, Spline and Shape. I toggled Preview Falloff to display them with a red-blue gradient.

This type of effect is very frequently used in motion design-style setups, especially animating falloffs using keyframes. Think Maya MASH or Cinema 4D Effectors.

Say we wanted to animate the size of our objects using a falloff. Let’s create an object falloff attached to the Template Object and add a new MOPs Randomize to set the object size based on the falloff. Turn off Enable Falloff in the first MOPs Randomize since we don’t want our new falloff to affect it.

Now we can keyframe the position of the falloff object, giving us animated instances!

One thing this type of effect might remind you of is audio visualizers where the animation reacts to an audio track. Wouldn’t it be cool if we could easily implement that type of effect?

It is cool and with MOPs it is easy! There is a dedicated node for exactly this task: Mops Audio Falloff. It lets us import an audio file and provides a comprehensive set of parameters for controlling how the audio is processed.

Initially, the node just responds to the amplitude of the audio on any given frame, so the effect is choppy. A classic feature of audio visualizers is they decay back to baseline. I added some VEX to implement that. This is another great use of the Solver node that we discussed in the last Node Nuggets. We can use it to build on the state of the animation from the previous frame.

The first wrangle adds to the Y position of every point based on the current state off the falloff. Note the opinput1_ syntax: this lets us fetch the mops_falloff attribute from the second connected input.

I also added a decay effect that makes the deformations in the surface of the grid slowly return to zero/flat when the amplitude lessens.

Finally, I added some quick and dirty colorization using VEX. This checks the height in the Y axis of any given point and assigns a color. This gives us an effect similar to a typical audio levels meter, differentiating loud and soft and everything in between using colors.

A lot of the instancing and attribute modification tasks we’ve discussed here could be done in vanilla Houdini, but it wouldn’t necessarily be pleasant. MOPs makes it easy to get to work creating the effects you want instead of wrestling with Houdini esoterica.

This should give you a great foundation to use MOPs in your own projects. All MOPs tools follow a similar structure, so it should be no problem to learn how the others work and intuitive apply them as needed.

I’ll close with another useful tool, MOPs Move Along Spline. Making an object follow a “track” is a common task in 3D, especially for camera movement. Houdini has built-in tools for this, but nothing beats MOPs’ version for sheer convenience and flexibility. With only a few clicks you can have a working setup that allows for great granular control, including object orientation and acceleration. Have fun!