From cgwiki



Kinefx covers a lot of ground, but there's a pleasing DNA share with a lot of established houdini workflows. It also makes a point to seperate a few rigging and animation concepts which other packages tend to merge together. More explainations below, but at a high level:






Given a skin with weights, and a bind pose (called a rest pose in Houdini) and a moving set of joints, move the skin. But how do you move those joints?


I said 'high level', but this is one of the biggest conceptual changes of kinefx rigging vs other systems, it needs more words...

A rig is way to move joints around. Self evident, sure, but spend some time thinking about this.

If joints are just points like everything else in sops, you could use a transform sop to move them around. And just like everywhere else in sops, if you do this, its totally freeform; it won't care about the lines between the points, or the connectivity, do what you want, use an edit sop, soft transforms, fine. That's a rig.

It's likely that you'll want to maintain the relationships between your joints though. So if you rotate a shoulder, the elbow and wrist and hand joints should rotate too. A Rig Pose sop gives you this, its a transform sop that is aware of joints, and gives you FK abilities. So a rig pose sop is a rig.

But you probably want IK too right? Well what do you need at the minimum for IK, a skeleton and a IK target? Well lucky for you there's an IK chains sop, give it those inputs, you get your IK. So the IK chains sop is a rig.

'Wait a sec, if this is houdini, and sops has great vex and vops support, and kinefx is in sops... can I use vex and vops in rigs?' Why yes you can! A Rig Wrangle and a Rig Vop are designed for this, giving you manipulation of points which is skeleton hierarchy aware. So vex and vops are also rigs.

And there's more, like foot roll vops, and FBIK sops, and skeleton blend sops etc. Rigs are sops.

Sop modelling vs sop rigging

Quick aside to talk about sops for modelling.

In sops for modelling, you chain nodes together, and geo flows and gets modified from one node to the next.


Now lets do a search and replace on the above statement, for how kinefx operates:

In sops for rigging, you chain nodes together, and animation+joints flow and get modified from one node to the next.

If you have a 'live' rigging chain of skeleton, rig pose, FBIK, foot-roll, you generally don't expect to see all those controls on screen at once. You select each node, do a thing, go to the next node. If you DO want a master control, you have to wire them up to a controller null, or make an HDA and expose all the controls at the top.




Motion clips


This covers similar ground to what chops does (the idea of swapping time for modelling and back again), but much simplified, and staying in comfortable sops land.

Right, enough overview. Lets move onto details!

Rig vs deformation



In Houdini, you'll see this:

Paul rig.png
60fps gif of complex dance. Damnit Paul, move!


Paul rig2.png
Shake it Paul!


Paul flail.gif


Paul twerk.gif
No words for such beauty.


Paul fbx export.gif


Motion clips









Some ideas to think about:


Motion clip editing via motion trails

Kinefx moclip trail howto6.gif

Download hip: File:kinefx_adjust_motionclip_trail.hip

A cool feature of motion clips is the motion clip extract sop, which lets you swap from entire-skeleton-as-a-snapshot-per-frame, to motion-trail-per-joint. You can edit these curves however you want, then update the original motion clip with the motion clip update sop. Just remember to turn off 'prefer using local transforms'.

This is a lame example, as are all my examples, but shows the potential behind this workflow.

Localtransform and kinefx wrangle




  1. Make a line with 10 segments
  3. Append a rig wrangle
  4. Try something like this:







Kinefx starfish.gif

Download hip: File:kinefx_starfish.hip

Unroll curves with kinefx

Curve unroll kinefx.gif

Download hip: File:kinefx_unroll_curves.hip

As I just mentioned, you can recreate what the CurveUnrollTutorial does much more elegantly with kinefx, as well as some other helper sops that arrived after writing that original tutorial.

The orient along curve sop does what it says, and gives you a clean orient attribute at each point on a curve. A rig doctor is used to get curves ready to be manipulated by kinefx, specifically setting the @localtransform to be driven by the orient we just calculated.

The rig wrangle is basically the same ideas as the unroll tutorial. For each joint calculate the dihedral between its local z-rotation, and a vector pointing directly down the z-axis. Rotate each joint by this amount, staggering the timing so the curve gets an animated unroll, done. Here's the snippete if you're in a hurry:

vector4 q;
vector r, angleaxis, axis;
float angle, acc;

// generate a z-axis of rotation per joint
r = {0,0,1}*matrix3(4@localtransform);

// dihedral will give us a quaternion to align {0,0,1} to r
// prerotate() requires angle and axis, so convert
q = dihedral(r, {0,0,1});
angleaxis = qconvert(q);
angle = length(angleaxis);
axis = normalize(angleaxis);

// stagger rotation along curve
acc = ch('acc');
angle *= clamp((1-@uv.x)*acc-acc+ch('mult')*acc,0,1);

// rotate!
prerotate(4@localtransform, angle, axis);

Proper rotation in a rig wrangle with prerotate

Much thanks to Stephan Walsch and Henry Dean for this one.

Short version: When rotating @localtransform attributes in a rig wrangle, use prerotate() instead of rotate().

Long version:

The previous wrangle trick works fine for lots of joints, but if you use want to rotate a specific joint in a wrangle like a rig pose does, it behaves unexpectedly. Here's a simple root/middle/tip 3 joint chain to represent a shoulder/elbow/wrist. If I use a rig pose to select and rotate the elbow, it behaves as expected; the joint itself rotates, the wrist comes along for the ride:

Rigpose rotate.gif

To replicate that in a rig wrangle, I'll use the rotate() vex function:

vector axis = {1,0,0};
float angle = radians(ch('angle'));
rotate(4@localtransform,angle, axis);

If I run this in points mode so it applies to all the joints, the arm curls up as expected:

Kinefx wrangle rotate.gif

But if I limit it to just the elbow (ie point 1), it doesn't behave as expected; it rotating everything from the shoulder!

Kinefx rotate joint1.gif

If I make it just animate the wrist (joint 2), it looks correct at first glance:

Kinefx rotate tip2.gif

But look closely, the elbow is wrong. Yes it's staying in the right location, but it's also not rotating (the axis handles aren't moving). More importantly, we shouldn't have to employ tricks like "if you want to rotate the elbow in a wrangle, remember to select the wrist", that's crazy.

Luckily the fix is simple. Go back to rotating the elbow and instead of rotate(), use prerotate():

Kinefx prerotate.gif

Why? It's easier to play with than to explain in words, but its a combination of how matricies combine, and how they're defined, and how kinefx applies joint transformations.

First, when combining matricies, order is important. If matrix A represented 'move forward 1 unit' and matrix B represented 'rotate 45 degrees right', multiplying those matricies will combine them, but AxB will look different to BxA:

Kinefx matrix order.gif

Secondly, a matrix could be defined in worldspace, or defined in relation to other matricies. The kinefx @localtransform matrix is the latter, it's describes each joint rotation relative to its parent. That means if you use rotate() on localtransform, it too rotates relative to the parent. Hence rotate() on the elbow ended up rotating from the shoulder.

The prerotate() vex function does as the name implies, it applies the rotation to the matrix first. Ok, but first compared to... what?

Well, a key job of a rig wrangle, a rig pose, a rig vop etc is to update the positions of the joints, ensuring transforms of parents are passed to children. By pre-rotating, the matrix of the joint you specify is rotated first, then when the rig pose updates transforms, it then gets moved to the right position relative to the parent.

Interestingly as a bonus aside, I happened to look at the help for the rig pose node, and it explains how you have a choice per animation to work in premult or postmult modes, and check it out, the default mode is premult, so this actually aligns with what I've just learned about rotate vs prerotate in vex. Go figure.


Rigpos premult.png

In other words, if things are behaving strangely, use prerotate. :)

IK Chain Legs Setup

Ik chains legs.PNG

Download hip: File:kinefx_ik_chain_legs.hip

The Ik Chain sop is relatively simple, but can be a bit of a puzzle the first time you get it going. This hip starts with a basic IK chain rig, and adds features until it ends up with a leg IK setup that could be animated, and present a clean interface to the user.

The challenge lies in the base differences of how sops works vs what you expect from an animation rig. Sops lets you display a single node, and have a single active tool context. You can use template flags, but that can get complicated with more than 2 nodes, and it definitely doesn't let you interact with 2 nodes at once.

An animation rig isn't compatible with this at first glance; you need to display and edit the ik handles for the feet, display and edit the 'fk' handle for the hips, while also displaying the full posed skeleton and potentially skinned geo, all at the same time.

You can get what you want out of kinefx with a bit of juggling. The trick here is to pull all the handles you want into a single rigpose, then split them out again to send to the relevant nodes. Here the hips go to a skeleton blend sop, while the ik handles go to the ik chains sop.

When you get a handle on this workflow its pretty powerful and freeform, allowing for interesting rig layering tricks that'd be hard in standard animation packages. The flipside is it can create a bit of a node salad. Ideally you'd wrap all this up into HDAs.

The display+selection, plus some of the gotchas can be hard to understand just from a hip, so I've made a little walkthrough you can watch here:



Kinefx fbik.gif

Download hip: File:kinefx_fbik_hips.hip








Proximity skinning

Kinefx skin.png

Download hip: File:kinefx_skin_simple.hip




If you want to refine the weights, use a capturelayerpaint.


Biharmonic skinning

Kinefx biharm screenshot.png

Download hip: File:kinefx_biharmonic_skin.hip



I'm trying to commit these steps to memory:

  • Make your skeleton and a reasonably high res skin
  • BoneCaptureLine to define capture regions for the joints

Manually drawing a skeleton


Skeleton sop hotkeys.png


  • r.click, split to create elbow

Rig from labs straight skeleton

Kinefx straight skel.png

Download hip: File:kinefx_straight_skeleton.hip



Rig doctor to help debug curve direction

Kinefx rigdoctor parent to child.gif


Procedural weights

Kinefx procedural weights loop.gif

Download hip: File:kinefx_procedural_weights.hip









Fix orient.png

Thanks Noel!

Kinefx to agents to lops to arkit

Kinefx arkit.gif

Download hip: File:kinefx_to_agents.hip


  • ARKit on iOS uses USDZ.
  • Houdini can export USDZ!
  • ARKit doesn't support arbitrary shape animation.
  • ARKit does support skeletal animation!
  • USDZ doesn't support arbitrary standalone skeletal animation.
  • Houdini can export crowd agents to USDSkel via Lops!!

Exciting right?



Rig vop



The biggest clue here is that it's set to detail mode by default. Why? Well in a 'proper' character rig context, you're doing specific things to 3 or 4 joints, not every joint. Eg:


Easier to explain with an example.

Floating parent constraint

Rig vop parent paul small.gif

Download hip: File:Kinefx rig vop parent.hip



First, lets get the rig vop and viewport ready:

  1. Make a rig vop


  1. Drag the head joint from the 3d view into the vop network. Yes really. It will make you a get transform vop for the head.
  2. Click the root of one bunny year. It splits in 2. Drag the upper one to the viewport, above the head transform vop. This will make a get transform for the ear.
  3. Click the root of the ear again, it splits, this time choose the lower dot. Drag it in and put it over on the right, this will create a set transform for the ear.
  4. Make a parent constraint vop, put it in the middle.



Quick gif summary:

Rigvop parent process.gif

Misuse of a rig vop in point mode

Rig vop.png


