Non-Roll Shoulder Test

Looking at different forums lately and there has been a lot of inquiry one the topic of non-roll shoulders and how to create them. So I thought I would post a PlayBlast of my solution to promote some thoughts and discussion.

9 Responses to “Non-Roll Shoulder Test”

  1. Did you ever figure out a good solution for the non-roll shoulder? It’d be aaaaaawwwesome to have a tutorial or some insight in what you did 😀

  2. Hey folks,

    I just stumbled onto a “no-roll” shoulder solution that is extremely successful (for both FK and IK arm posing.) You create a sibling upper arm chain (I’ll refer to them as Dup_Armu and Dup_Arml) and create an ikRP handle for them. Create a locator at the position of Dup_Armu and pole-vector-constrain the ikRP handle to it (should result in rotation plane of 0,0,0). Parent ikRP handle to the original Armu. Now you should have a duplicate chain that follows the original Armu’s rotation with NO ROLL ROTATION. Next, create a locator that is the same position and orientation as the dup_Armu. Parent it to dup_Armu. Next do an orient-constraint (rotation-axis ONLY) of the locator to the original Armu. This locator should explicitly track the ROLL OFFSET between the two chains. Use this value to drive expressions for your counter-rotating helper bones on the original arm chain!

    Once you set it up once, you’ll see that it’s not as complicated as it sounds. Pretty rock-solid, too.

  3. The IK handle *will* filp at 180 degrees opposite the setup pose. If you character is in an airplane pose or arms at 45 degrees, this will not represent a problem, as 180 degrees off from these poses is not physically probable. If you character is zeroed out with arms at his sides, you will probably get flipping when you raise his arms straight up, opposite his bindpose.

  4. //Here’s a sample of a melscript that automates this type of setup on my arm bones (oriented with X as the rotation axis). Also important to note is that my local orientation values are all zeroed out at bindpose.

    //make an empty group to own this stuff
    string $helpers = “MyHelpers”;
    group -em -n $helpers;
    //Here’s where I specify the bone to use, starting at the shoulder///
    $array = stringToStringArray(“L_Shoulder L_Armu L_Arml”, ” “);
    select -r $array[0];
    //Copy the arm hierarchy, remove all extraneous bones and rename the one’s well use as “twist_bone”//
    string $dup0 = “twist_” + $array[0];
    string $Sdup1 = $dup0 + “|” + $array[1];
    string $Sdup2 = $Sdup1 + “|” + $array[2];
    string $dup1 = “twist_” + $array[1];
    string $dup2 = “twist_” + $array[2];
    string $ikHandle = $dup1 + “_ikHandle”;
    rename $dup0;
    parent -w;
    select $Sdup2;
    rename $dup2;
    select $Sdup1;
    rename $dup1;
    select -r $dup0; SelectHierarchy;
    select -tgl $dup0 $dup1 $dup2;
    //Make and ikRP solver for the duplicate arm//
    select -r $dup1 $dup2;
    ikHandle -sol ikRPsolver;
    rename $ikHandle;
    //Make the pole vector locator where the upper arm duplicate is. While I’m at it, make the twist tracker locator as well//
    string $ikPole = “loc_” + $dup1;
    string $twistTracker = $dup1 + “_Xrot”;
    spaceLocator -n $ikPole;
    pointConstraint $dup1 $ikPole;
    orientConstraint $dup1 $ikPole;
    select -r $ikPole;
    delete -constraints;
    duplicate -n $twistTracker;
    pointConstraint $dup1 $ikPole;
    parent $twistTracker $dup1;
    //Parent constrain the duplicate shoulder to the original
    parentConstraint $array[0] $dup0;
    //Pole vector constrain the handle to the pv locator
    poleVectorConstraint $ikPole $ikHandle;
    //Parent constrain the ik handle to the original lower arm
    parentConstraint $array[2] $ikHandle;
    //Orient constrain the twist tracker to the original arm, excluding non-twist axes//
    orientConstraint -offset 0 0 0 -skip y -skip z -weight 1 $array[1] $twistTracker ;
    //Put all of this junk under our neat little group node
    parent $dup0 $ikHandle $ikPole $helpers;

  5. Oh, forgot to mention, the resulting “Rotation Tracker” is what we use to generate values to drive the counter-rotation of helper bones on the original arm skeleton (which will distribute the upper arm twist over its length.)
    For example, to remove all rotation influence, you would create an expression that made the rotation of your “non-twist” helper bone the negative-rotateX value of the twist tracker. The bicep twist bone could use negative 50% of the twist tracker value, etc.

  6. nice one, do you know this one ?

    pretty simple and easy concept.

    i´m lookinf foward your awesome spine tutorial,
    keep it up !

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: