It’s been a little while since the last release and I wanted to add a brand new toy to the next one that would be fun for animators to work with. Here’s MOPs+ Rig Aim! It’s a lot like MOPs Aim but it works on KineFX joints:

It operates in order from root to tip on any joint chains you apply it to, so you can use it to gradually bend complex hierarchies towards a target. It’s not too difficult to bias a single KineFX joint towards a target orientation, but doing it to multiple joints and having them solve their aim vectors in order so they don’t overshoot is a bit more complicated!

Of course there’s plenty of snags to work out… not every rig is cleanly built, and sometimes you’ll end up with joint orientations that point in opposite directions when mirrored. That leads to all kinds of broken fun interpretations when aiming multiple joint chains:

This will take a bit of work to tune up and built a coherent interface for, but I’m looking forward to finishing it up so I can push the next release! I think it’ll be a really entertaining way to art direct more difficult kinematic chains for things like tentacles, trees, or other weird wiggly things.

Stay tuned!

I’m reworking some of the internals of MOPs+ Collision Geo, a SOP that’s meant to simplify creating lightweight Bullet proxies for packed primitives, including deforming sequences, while ensuring instanced geometry is only simplified once. This means you can create a big mess of instanced objects and have consistent collision representation for all of them in one go, without having to reorganize anything about your network. It’s very quick in most cases!

Version 1.0 was working pretty well, but it felt a little clunky in a couple places. First of all, while the Convex Decomposition mode worked great in most cases for breaking geometry apart into convex hulls, the alternative Tetrahedralize mode was just far too slow to be worth using in anything but the most extreme cases. The idea was to turn complex objects into tets that are inherently convex, but in practice you had to generate so many of them that it was never worth the effort.

Thanks to a very cool video presentation by Lewis Taylor, I decided to replace that old mode with a new one that utilizes his described method to efficiently add more Voronoi cells for fracturing where the geometry is more concave. This means that the more convex parts of your mesh can be fractured with less points, which results in less chunks in areas where you don’t need them. It’s pretty brilliant in its simplicity!

The parameter interface also needed a bit of cleanup to make it easier to get to the most relevant tweaks more quickly. I was removing all the Tetrahedralize options anyways, so it made sense to give the whole UI an overhaul. I mentioned this in my latest Houdini HIVE presentation, but in general I try to set up interfaces to work top to bottom, left to right, big to small, so that the broadest options or the first things to consider are handled first, and the fine-tuning or finishing options are encountered later.

The other big thing to handle was improving how the operator handled incoming geometry that wasn’t instanced… in version 1.0, the operator would simply fail and claim that all input geometry needed to be packed. From the developer’s perspective this made sense, but to an end user it was just another hurdle to worry about. I’ve since rewritten a number of similar nodes that used to throw errors when the “wrong” input was given (such as geometry with no id attribute) and instead just throw a warning and try to handle the conversion within the SOP. I think it’s a much smarter way to go, as it allows the user to maintain flow and interactivity while still letting them know that they should be on the lookout for weird behavior just in case.

Here’s a quick example showing the new MOPs Collision Geo operating on both packed primitives and a polygon-based collision mesh that’s deforming. There are two types of instances that are randomly position, oriented and scaled, and MOPs knows to create only one decomposed proxy for each type of instance and then transform and copy them to match. For the deforming collider, MOPs decomposes in-place based on a rest frame and then transforms the pieces to match the deformation. This is much cheaper than trying to use a deforming collider, which would have to be re-imported into the DOP simulation on every timestep.

On my 9900X this runs at about 12 fps, and the Collision Geo SOP only takes about a second and a half on the deforming grid for the initial cook. The cook for the instances is basically instantaneous.

Demo Licensing

I’m also in the process of getting a trial MOPs+ license structure included. Getting this integrated with the website and MOPs+ accounts and all that might take a while, but once the new structure is up and running I’ll have demo licenses available by request. You know where to find me!