// Copyright Digital Pictures 2003. All Rights Reserved
//
// Author:
//	Stuart Bryson

global proc doModularRigHelp() {
	window
		-title "ModularRig v0.1"
		-iconName "ModularRig"
		-titleBar true
		-minimizeButton true -maximizeButton true
		-h 400 -w 310
		-sizeable true;
		scrollLayout
			-verticalScrollBarThickness   16
			-horizontalScrollBarThickness   16;
		columnLayout -adjustableColumn true;
			text -align left -label 
(
"No help has yet been writen for this script.\n" + 
"If it is needed urgently contact rnd@gmd.com.au.\n"
);
		setParent ..;
	showWindow;
}

//######################################################################################
//# FUNCTIONS FOR CONTROLS, SELECTION HANDLES ETC
//######################################################################################
proc setAndLockAttrs(string $obj, string $attributes[], float $value) {
    string $attr;
    for ($attr in $attributes) {
        setAttr -lock true ($obj + "." + $attr) $value;
    }
}

proc removeChannels(string $objects[], string $attributes[], int $lock) {
    string $obj, $attr;
    for ($obj in $objects) {
        for ($attr in $attributes) {
            if ($lock) {
                setAttr -lock true ($obj + "." + $attr);
            }
            setAttr -k off ($obj + "." + $attr);
        }
    }
}

proc toggleSelectionHandles(string $objects[]) {
    string $obj;
    for ($obj in $objects) {
        toggle -selectHandle $obj;
    }
}

proc toggleSelectionHandle(string $object) {
    toggle -selectHandle $object;
}

proc toggleSelectionHandlesWithOffset(string $objects[], float $offset[]) {
    string $obj;
    float $loc;
    for ($obj in $objects) {
        toggle -selectHandle $obj;
        $loc = `getAttr ($obj + ".selectHandleX")`;
        setAttr ($obj + ".selectHandleX") ($offset[0]+$loc);
        $loc = `getAttr ($obj + ".selectHandleY")`;
        setAttr ($obj + ".selectHandleY") ($offset[1]+$loc);
        $loc = `getAttr ($obj + ".selectHandleZ")`;
        setAttr ($obj + ".selectHandleZ") ($offset[2]+$loc);
    }
}

proc toggleSelectionHandleWithOffset(string $obj, float $offset[]) {
    float $loc;
    toggle -selectHandle $obj;
    $loc = `getAttr ($obj + ".selectHandleX")`;
    setAttr ($obj + ".selectHandleX") ($offset[0]+$loc);
    $loc = `getAttr ($obj + ".selectHandleY")`;
    setAttr ($obj + ".selectHandleY") ($offset[1]+$loc);
    $loc = `getAttr ($obj + ".selectHandleZ")`;
    setAttr ($obj + ".selectHandleZ") ($offset[2]+$loc);
}


//NOTE The order of colouring a heirachy is important - always colour from top down so as not to override the child objects
// colour an object with a user defined colour
proc colourObjectWithColour(string $object, int $colour) {
    color -ud $colour $object;
}

// colour all objects with a user defined colour
proc colourObjectsWithColour(string $objects[], int $colour) {
    color -ud $colour $objects;
}

// colour objects with different user defined colours
proc colourObjectsWithColours(string $objects[], int $colours[]) {
    string $obj;
    int $i;
    
    // check number of objects matches number of colours
    if (size($objects) > size($colours)) {
        error "Too many objects and not enough colours when colouring objects";
    } else if (size($objects) < size($colours)) {
        error "Too many colours and not enough objects when colouring objects";
    }
    
    for ($i=0; $i<size($objects); $i++) {
        color -ud $colours[$i] $objects[$i];
    }
}


//######################################################################################
//# USEFUL FUNCTIONS
//######################################################################################
// remove element from an array
proc string[] removeElementAtIndex(string $items[], int $removeIndex) {
    string $return[];
    int $i;
    
    for ($i=0; $i<$removeIndex; $i++) {
        $return[size($return)] = $items[$i];
    }
    for ($i=$removeIndex+1; $i<size($items); $i++) {
        $return[size($return)] = $items[$i];
    }
    return $return;
}

// to speed this function up it was decided that the indexes MUST be in order
//NOT TESTED YET!
proc string[] removeElementsAtIndexes(string $items[], int $removeIndexes[]) {
    string $return[];
    int $i, $currentRemoveIndex = 0;
    for ($i=0; $i<size($items); $i++) {
        if ($i != $removeIndexes[$currentRemoveIndex]) {
            $return[size($return)] = $items[$i];
        } else {
            print ("Ignoring "+$items[$i]+"\n");
            $currentRemoveIndex++;
            if ($currentRemoveIndex >= size($removeIndexes)) {
                return $return;
            }
        }
    }
    return $return;
}

// Vector (float array) functions...
proc float[] vecAdd(float $a[], float $b[]) {
    float $result[];
    $result[0] = $a[0] + $b[0];
    $result[1] = $a[1] + $b[1];
    $result[2] = $a[2] + $b[2];
    return $result;
}

proc float[] vecSub(float $a[], float $b[]) {
    float $result[];
    $result[0] = $a[0] - $b[0];
    $result[1] = $a[1] - $b[1];
    $result[2] = $a[2] - $b[2];
    return $result;
}

proc float[] vecMultFloat(float $a[], float $b) {
    float $result[];
    $result[0] = $a[0] * $b;
    $result[1] = $a[1] * $b;
    $result[2] = $a[2] * $b;
    return $result;
}

proc float[] vecDivFloat(float $a[], float $b) {
    float $result[];
    $result[0] = $a[0] / $b;
    $result[1] = $a[1] / $b;
    $result[2] = $a[2] / $b;
    return $result;
}

// returns a subset of a float array from start to end indicies
proc float[] vecIndex(float $array[], int $start, int $end) {
    float $result[];
    int $i;
    for ($i=$start; $i<=$end; $i++) {
        $result[size($result)] = $array[$i];
    }
    return $result;
}

// returns a subset of a string array from start to end indicies
proc string[] vecIndexString(string $array[], int $start, int $end) {
    string $result[];
    int $i;
    for ($i=$start; $i<=$end; $i++) {
        $result[size($result)] = $array[$i];
    }
    return $result;
}

// Creates a Locator given the name, position and scale and returns the new locators name
proc string createLoc(string $name, string $parent, float $pos[], float $scale)
{
    string $parents[], $loc[];
    $loc = `spaceLocator`;
    setAttr ($loc[0] + ".sx") $scale;
    setAttr ($loc[0] + ".sy") $scale;
    setAttr ($loc[0] + ".sz") $scale;
    move -a $pos[0] $pos[1] $pos[2] $loc[0];
    $loc[0] = `rename $loc[0] $name`;
    $parents = `parent $loc[0] $parent`;
    return $loc[0];
}

// creates a group of locators (or lodacators :) N/M)
proc string createLocGroup(string $groupName, string $names[], float $locLocs[], float $scale) {
    int $i;
    string $group = `group -em -n $groupName`;
    
    // Check that the number of locators given times 3 equals the number of positions given (x,y,z for each)
    if (size($names)*3 > size($locLocs)) {
        error "When creating locator group: Too many names specified or not enough points specified";
    } else if (size($names)*3 < size($locLocs)) {
        error "When creating locator group: Not enough names specified or too many points specified";
    }
    // Check that the new group has the correct name....
    if (strcmp($group, $groupName) != 0) {
        warning ("Could not create group " + $groupName + " as there is probably already a group with that name.");
    }
    // for each locator, create it, move it and parent it to the new group
    for ($i=0; $i<size($names); $i++) {
        string $temp[] = `spaceLocator`;
        move -a $locLocs[$i*3] $locLocs[$i*3+1] $locLocs[$i*3+2] $temp[0];
        setAttr ($temp[0] + ".sx") $scale;
        setAttr ($temp[0] + ".sy") $scale;
        setAttr ($temp[0] + ".sz") $scale;
        parent $temp[0] $group;
        rename ($group + "|" + $temp[0]) $names[$i];
    }
    return $group;
}

// create a curve within a group and return the group
proc string createCurveGroup(string $groupName, string $curveName, float $cvLocs[]) {
    int $i;
    string $cmd, $curve;
    string $group = `group -em -n $groupName`;
    
    // check that cvLocs is divisible by 3
    // if blah
    
    // Check that the new group has the correct name...
    if (strcmp($group, $groupName) != 0) {
        warning ("Could not create group " + $groupName + " as there is probably already a group with that name.");
    }
    
    $cmd = "curve -d 3 ";
    // for each point add to the eval command
    for ($i=0; $i<size($cvLocs); $i=$i+3) {
        $cmd = $cmd + "-p " + $cvLocs[$i] + " " + $cvLocs[$i+1] + " " + $cvLocs[$i+2] + " ";
    }
    $curve = eval($cmd);
    parent $curve $group;
    rename ($group + "|" + $curve) $curveName;
    return $group;
}
        
//used for the hands...
proc string createLocGroupTree(string $groupName, string $parentNames[], string $childNames[], float $parentLocs[], float $childLocs[], float $scale) {
    int $i;
    string $temp[], $group;
    
    $group = `group -em -n $groupName`;
    
    // Check that the number of locators given times 3 equals the number of positions given (x,y,z for each)
    if (size($parentNames)*3 != size($childNames)*3 || size($parentNames)*3 != size($parentLocs) || size($parentNames)*3 != size($childLocs)) {
        error "When creating locator group tree: size of arguments to not match";
    }
    // Check that the new group has the correct name....
    if (strcmp($group, $groupName) != 0) {
        warning ("Could not create group " + $groupName + " as there is probably already a group with that name.");
    }
    // for each parent, create it, move it and parent it to the new group
    for ($i=0; $i<size($parentNames); $i++) {
        // create the parent locator and parent to the new group
        $temp = `spaceLocator`;
        move -a $parentLocs[$i*3] $parentLocs[$i*3+1] $parentLocs[$i*3+2] $temp[0];
        setAttr ($temp[0] + ".sx") $scale;
        setAttr ($temp[0] + ".sy") $scale;
        setAttr ($temp[0] + ".sz") $scale;
        parent $temp[0] $group;
        rename ($group + "|" + $temp[0]) $parentNames[$i];
        // create the child locator and group to the new parent
        $temp = `spaceLocator`;
        move -a $childLocs[$i*3] $childLocs[$i*3+1] $childLocs[$i*3+2] $temp[0];
        setAttr ($temp[0] + ".sx") $scale;
        setAttr ($temp[0] + ".sy") $scale;
        setAttr ($temp[0] + ".sz") $scale;
        parent $temp[0] ($group + "|" + $parentNames[$i]);
        rename ($group + "|" + $parentNames[$i] + "|" + $temp[0]) $childNames[$i];
    }
    return $group;
}

// Returns a list of objects in the list 'locs' that do not exist
proc string[] checkLoc(string $locs[]) {
    string $locator, $missing[];
    for ($locator in $locs) {
        if (!`objExists $locator`) {
            $missing[size($missing)] = $locator;
        }
    }
    return $missing;
}

proc reportMissing(string $missing[], string $missingFrom, int $die) {
    int $i;
    string $errorMsg = "The following locators are missing from " + $missingFrom + ": ";
    for ($i=0; $i<size($missing)-1; $i++) {
        $errorMsg = $errorMsg + $missing[$i] + " ";
    }
    $errorMsg = $errorMsg + "and " + $missing[size($missing)-1] + ".\n";
    if ($die) {
        error $errorMsg;
    } else {
        warning $errorMsg;
    }
}

// Creates a skeleton given a root joint, the joint locs in ws, the up vectors in ls and the joint names

// root joint is the name of the root joint to attatch the finger
// joint locs is an array of x,y,z coordinates for each joint. eg. 1,2,3,4,5,6,7,8,9 the second joint would be 4,5,6
// joint names is an array of names to be set for each joint... the size of this array times 3 should equal the size of joint locs
// the last joint is now oriented to the vector between the 2nd last and the last joint in the array

global proc string[] modRigBuildJoints(string $root, float $jointLocs[], float $upVectors[], string $jointNames[], string $prefix) {
    string $joints[], $jointsTopLevel[], $joint, $aimUpLoc[], $aimUpLocs[], $aimConst[], $lslong[], $temp[];
    float $orient[], $upVector[], $jointLoc[], $a[], $b[], $vec[];
    int $i;
    int $globalUpVector = 0; // true if only one up vector is specified for every joint
    
    // Check values...
    if (size($jointNames) * 3 > size($jointLocs)) {
        error "Too many joint names specified or not enough joint points specified.\n";
    } else if (size($jointNames) * 3 < size($jointLocs)) {
        error "Not enough joint names specified or too many joint points specified.\n";
    }
    if (size($jointLocs)%3 != 0) {
        error "Joint Loc array not divisible by 3.\n";
    }
    if (size($upVectors) != 3 && size($upVectors) != size($jointLocs)) {
        error "You must specify either one up vector for all joints or multiple up vectors, one for each joint.\n";
    }
    if (size($upVectors) == 3) {
        $globalUpVector = 1;
    }
    
    $numOfJoints = size($jointLocs)/3;

    select -cl;
    
    // Create the first joint outside the loop as the loop references root
    // We do not want to play with the joint orients of the root joint...
    $joints[0] = `joint -p $jointLocs[0] $jointLocs[1] $jointLocs[2] -n ($prefix + $jointNames[0] + "#")`;
    // top level refers to just the node name and not the full path of the joint, this joint should be parented to world anyway
    $jointsTopLevel[0] = $joints[0];
    
    // joint may not return the full path and this may create problems later so we ls -l to get the full path
    $lslong = `ls -l $joints[0]`;
    if (size($lslong) > 1) { warning ("ls -l returned more than one match for the joint: " + $joints[0]); }
    $joints[0] = $lslong[0];
        
    // Create the remaining joints
    for ($i=1; $i<$numOfJoints; $i++) {
        // Create joint
        $joints[$i] = `joint -p $jointLocs[$i*3] $jointLocs[($i*3) + 1] $jointLocs[($i*3) + 2] -n ($prefix + $jointNames[$i] + "#")`;
        
        // joint may not return the full path and this may create problems later so we ls -l to get the full path
        $lslong = `ls -l $joints[$i]`;
        if (size($lslong) > 1) { warning ("ls -l returned more than one match for the joint: " + $joints[$i]); }
        $joints[$i] = $lslong[0];
        
        // Ungroup it so we can aim constrain
        $temp = `parent -w $joints[$i]`;
        if (size($temp) > 1) { warning ("parent returned more than one value when parenting " + $joints[$i] + " to the world."); }
        $jointsTopLevel[$i] = $temp[0];
        
        // get the upvector for this joint
        if ($globalUpVector) {
            $upVector[0] = $upVectors[0];
            $upVector[1] = $upVectors[1];
            $upVector[2] = $upVectors[2];
        } else {
            $upVector[0] = $upVectors[$i*3];
            $upVector[1] = $upVectors[$i*3 + 1];
            $upVector[2] = $upVectors[$i*3 + 2];
        }
        // create a locator at the world space position of the joint to be constrained
        $jointLoc = `xform -q -ws -rp $jointsTopLevel[$i - 1]`;
        $aimUpLoc = `spaceLocator -n ($jointsTopLevel[$i] + "_AimLoc")`;
        // store aim up locators so we can delete them later... for some reason it barfs if we try to delete them too soon
        $aimUpLocs[$i] = $aimUpLoc[0];
        move -a -ws ($jointLoc[0] + $upVector[0]) ($jointLoc[1] + $upVector[1]) ($jointLoc[2] + $upVector[2]) $aimUpLoc[0];
        // aim constrain the joint to the next joint with the locator as our up vector
        $aimConst = `aimConstraint -wut "object" -aim 1 0 0 -u 0 1 0 -wuo $aimUpLoc[0] $jointsTopLevel[$i] $jointsTopLevel[$i - 1]`;
        delete $aimConst[0];
        
        // set the joint orients to the joint rotations and reset the rotations to 0
        $orient = `getAttr ($jointsTopLevel[$i - 1] + ".r")`;
        setAttr ($jointsTopLevel[$i - 1] + ".jo") ($orient[0]) $orient[1] $orient[2];
        setAttr ($jointsTopLevel[$i - 1] + ".r") 0 0 0;
        select -r $jointsTopLevel[$i];
    }
    
    // set the last joint's orients to the same as the second last joint's orients
    $orient = `getAttr ($jointsTopLevel[$i-2] + ".jo")`;
    setAttr ($jointsTopLevel[$i-1] + ".jo") $orient[0] $orient[1] $orient[2];
    
    for ($i=1; $i<$numOfJoints; $i++) {
        //print ("Parenting " + $jointsTopLevel[$i] + " to " + $jointsTopLevel[$i-1] + "\n");
        $temp = `parent $jointsTopLevel[$i] $jointsTopLevel[$i-1]`;
        if (size($temp) > 1) {
            warning ("parent returned more than one value when parenting " + $jointsTopLevel[$i] + " to " + $jointsTopLevel[$i-1]);
        }
        $lslong = `ls -l $temp[0]`;
        if (size($lslong) > 1) {
            warning ("ls -l returned more than one match for the joint: " + $temp[0]);
        }
        $joints[$i] = $lslong[0];
        delete $aimUpLocs[$i];
    }
    
    // Parent to the $root joint
    if (`objExists $root`) {
        parent $joints[0] ("|" + $root);
    }
    
    // Add the root joint to the joint names array to be returned (so we have the absolute path)
    for ($i=0; $i<$numOfJoints; $i++) {
        $joints[$i] = $root + $joints[$i];
    }
    
    return $joints;
}

// A function which reorients a joint to point at a locator and another locator as its up vector
// this is different to the modRigBuild func as it doesn't assume that the X axis should point at the next joint
// doesn't seem to work on last joint in the chain
global proc orientToLocators(string $joint, string $aim, string $up) {
    string $children[], $childTopLevel, $jointTopLevel, $aimConst[], $child, $temp[], $parent;
    float $orient[], $rotations[];

    $temp = `listRelatives -p $joint`;
    $parent = $temp[0];
    
    // parent child joint to the world
    $temp = `parent -w $joint`;
    if (size($temp) > 1) { warning ("parent returned more than one value when parenting " + $joint + " to the world."); }
    $jointTopLevel = $temp[0];
    
    // get the child joint object of the joint
    $children = `listRelatives -type joint $jointTopLevel `;
    
    // only parent the child joint if there is one!
    if (size($children) > 0) {
        $child = $children[0];
    
        // parent child joint to the world
        $temp = `parent -w $child`;
        if (size($temp) > 1) { warning ("parent returned more than one value when parenting " + $child + " to the world."); }
        $childTopLevel = $temp[0];
    }
    
    // set the joint orients to 0
    setAttr ($jointTopLevel + ".jo") 0 0 0;
    
    // add aim constraint
    $aimConst = `aimConstraint -wut "object" -aim 1 0 0 -u 0 1 0 -wuo $up $aim $jointTopLevel`;
    // delete the aim constraint
    delete $aimConst[0];
    
    // get the joint rotations
    $rotations = `getAttr ($jointTopLevel + ".r")`;
    // set the joint orients to the rotations
    setAttr ($jointTopLevel + ".jo") $rotations[0] $rotations[1] $rotations[2];
    // set the joint rotations to 0 0 0
    setAttr ($jointTopLevel + ".r") 0 0 0;
    
    parent $jointTopLevel $parent;
    if (size($children) > 0) {
        // parent the joint back to its original parent
        parent $childTopLevel $joint;
    }
}

// Creates a skeleton at the locator positions passed in and returns an array of joints
// should use orient constraints...
proc string[] skelAtLoc(string $root, string $locs[], float $upVectors[], string $prefix) {
    float $jointLoc[], $jointLocs[];
    string $joints[], $newJointNames[], $buffer[];
    int $i, $numTokens;
    select -cl;
    for ($i=0; $i<size($locs); $i++) {
        $jointLoc = `xform -q -ws -rp $locs[$i]`;
        $jointLocs[$i*3] = $jointLoc[0];
        $jointLocs[$i*3 + 1] = $jointLoc[1];
        $jointLocs[$i*3 + 2] = $jointLoc[2];
    }
    // need to strip the full path off $locs array so mod rig builds the joints with simpler names
    for ($i=0; $i<size($locs); $i++) {
        $numTokens = `tokenize $locs[$i] "|" $buffer`;
        $newJointNames[$i] = $buffer[$numTokens-1] + "#";
    }
    $joints = modRigBuildJoints($root, $jointLocs, $upVectors, $newJointNames, $prefix);
    return $joints;
}

// Deletes the list of locators
proc deleteLocs(string $locs[]) {
    string $locator, $type[];
    for ($locator in $locs) {
        if (`objExists $locator`) {
                delete $locator;
        } else {
            warning ("Could not delete " + $locator + ": does not exist.\n");
        }
    }
}

// very similar to the buildIKFKBlend function which joint orients every joint and blends between fk and ik,
// however this one constrains the orients using an expression rather than joint orients
proc buildAxisBlend(string $skelIK[], string $skelFK[], string $skelBind[], float $initialFKIKBlend, int $connectParentControl) {
    string $exp, $parents[], $oneBelowParent, $twoBelowParent;
    int $i;
    // check the skeletons match
    if (size($skelIK) != size($skelFK) || size($skelIK) != size($skelBind)) {
        error "The size of the skeletons do not match for axis blending.\n";
    }
    // create a keyable attribute on the root skeleton to blend between fk and ik
    addAttr -ln blend_fk_ik -at double  -min 0 -max 10 -dv $initialFKIKBlend $skelBind;
    setAttr -e -keyable true ($skelBind[0] + ".blend_fk_ik");
    
    $exp = "// calculate the fk and ik influence based on blend\nfloat $FKinf = 1-(" + $skelBind[0] + ".blend_fk_ik/10);\nfloat $IKinf = (" + $skelBind[0] + ".blend_fk_ik/10);\n";
    for ($i=0; $i<size($skelBind); $i++) {
        $exp = $exp + "\n" + $skelBind[$i] + ".rz = " + $skelFK[$i] + ".rz * $FKinf + " + $skelIK[$i] + ".rz * $IKinf;";
    }
    expression -s $exp -o "" -ae 1 -uc all;
    
    // Determine if the root or one below the root on the bind skeleton already has a blend control
    // if so just make a direct connection to our new blend attribute
    $parents = `listRelatives -p $skelBind[0]`;
    $oneBelowParent = "Not enough parents";
    $twoBelowParent = "Not enough parents";
    
    // Loop until parents equals nothing... ie the world is the parent, then test the two objects underneath to see if they have the blend attribute...
    while (strcmp($parents[0], "") != 0) {
        $twoBelowParent = $oneBelowParent;
        $oneBelowParent = $parents[0];
        $parents = `listRelatives -p $parents[0]`;
    }
    
    // if we want to control the blend attribute by a parent bind skeleton control
    if ($connectParentControl) {
        // if either of the two parents have the blend ik fk attr then connect it to the new attr
        if (strcmp($oneBelowParent, "Not enough parents") != 0) {
            if (`attributeExists "blend_fk_ik" $oneBelowParent`) {
                connectAttr -f ($oneBelowParent + ".blend_fk_ik") ($skelBind[0] + ".blend_fk_ik");
            } else if (strcmp($twoBelowParent, "Not enough parents") != 0) {
                if (`attributeExists "blend_fk_ik" $twoBelowParent`) {
                    connectAttr -f ($twoBelowParent + ".blend_fk_ik") ($skelBind[0] + ".blend_fk_ik");
                }
            }
        }
    }
}

// orients every single joint in the Bind skel to the fk and ik skeletons and creates a blend control on the bind skel
proc buildIKFKBlend(string $skelIK[], string $skelFK[], string $skelBind[], float $initialFKIKBlend, int $connectParentControl) {
    string $constraints[], $IKbuffer[], $FKbuffer[], $parents[], $oneBelowParent, $twoBelowParent;
    int $i, $numIKTokens, $numFKTokens;
    // check the skeletons match
    if (size($skelIK) != size($skelFK) || size($skelIK) != size($skelBind)) {
        error "The size of the IK, FK and Bind skeletons do not match for ik fk blending.\n";
    }
    // create a keyable attribute on the root skeleton to blend between fk and ik
    addAttr -ln blend_fk_ik -at double  -min 0 -max 10 -dv $initialFKIKBlend $skelBind;
    setAttr -e -keyable true ($skelBind[0] + ".blend_fk_ik");
    
    // orient every single joint in the bind skel to the ik and fk skels
    for ($i=0; $i<size($skelBind); $i++) {
        $constraints = `orientConstraint -w 1 -n "orCon" $skelIK[$i] $skelFK[$i] $skelBind[$i]`;
        // As our hip skel is full path we need to get just the dag node name in short form to use for the aim constraints.
        $numIKTokens = `tokenize $skelIK[$i] "|" $IKbuffer`;
        $numFKTokens = `tokenize $skelFK[$i] "|" $FKbuffer`;
        // *********THIS IS NAUGHTY... I should be querying the orient constraint to obtain the weights... not just assume it is W0 and W1
        setDrivenKeyframe -cd ($skelBind[0] + ".blend_fk_ik") -dv 0 -v 0 ($constraints[0] + "." + $IKbuffer[$numIKTokens-1] + "W0");
        setDrivenKeyframe -cd ($skelBind[0] + ".blend_fk_ik") -dv 0 -v 1 ($constraints[0] + "." + $FKbuffer[$numFKTokens-1] + "W1");
        setDrivenKeyframe -cd ($skelBind[0] + ".blend_fk_ik") -dv 10 -v 1 ($constraints[0] + "." + $IKbuffer[$numIKTokens-1] + "W0");
        setDrivenKeyframe -cd ($skelBind[0] + ".blend_fk_ik") -dv 10 -v 0 ($constraints[0] + "." + $FKbuffer[$numFKTokens-1] + "W1");
    }
    
    // Determine if the root or one below the root on the bind skeleton already has a blend control
    // if so just make a direct connection to our new blend attribute
    $parents = `listRelatives -p $skelBind[0]`;
    $oneBelowParent = "Not enough parents";
    $twoBelowParent = "Not enough parents";
    
    // if we want to control the blend attribute by a parent bind skeleton control
    if ($connectParentControl) {
        // Loop until parents equals nothing... ie the world is the parent, then test the two objects underneath to see if they have the blend attribute...
        while (strcmp($parents[0], "") != 0) {
            $twoBelowParent = $oneBelowParent;
            $oneBelowParent = $parents[0];
            $parents = `listRelatives -p $parents[0]`;
        }
    
        // if either of the two parents have the blend ik fk attr then connect it to the new attr
        if (strcmp($oneBelowParent, "Not enough parents") != 0) {
            if (`attributeExists "blend_fk_ik" $oneBelowParent`) {
                connectAttr -f ($oneBelowParent + ".blend_fk_ik") ($skelBind[0] + ".blend_fk_ik");
            } else if (strcmp($twoBelowParent, "Not enough parents") != 0) {
                if (`attributeExists "blend_fk_ik" $twoBelowParent`) {
                    connectAttr -f ($twoBelowParent + ".blend_fk_ik") ($skelBind[0] + ".blend_fk_ik");
                }
            }
        }
    }
}

// this just builds a direct orient constraint from one joint to another (ie, there is no blending between two drivers)
proc buildDirectConnections(string $driver[], string $driven[]) {
    int $i;
    // check the skeletons match
    if (size($driver) != size($driven)) {
        error "The size of the IK, FK and/or Bind skeletons do not match for a direct connection.\n";
    }
    for ($i=0; $i<size($driver); $i++) {
        $constraints = `orientConstraint -w 1 -n "orCon" $driver[$i] $driven[$i]`;
    }
}

// simple adds | to the start of each string referencing a node
proc string[] addRootReference(string $nodes[]) {
    string $newNodes[], $node;
    for ($node in $nodes) {
        $newNodes[size($newNodes)] = "|" + $node;
    }
    return $newNodes;
}


// used to get the selected root joint or the selected locator...
global proc string[] getSelected(int $jointsOrLocators) {    
    string $selected[], $object, $type[], $locators[], $roots[], $returnObjects[];
    int $j;
    
    // Grab the selected objects
    $selected = `ls -sl -l`;
    // See if we have a root joint or a locator selected...
    if (size($selected) > 0) {
        for ($object in $selected) {
            $type = `ls -st $object`;
            // if it is a transform then check that the required locators are below it...
            if (strcmp($type[1], "transform") == 0) {
                $locators[size($locators)] = $object;
            // if it is a joint then set root = joint
            } else if (strcmp($type[1], "joint") == 0) {
                $roots[size($roots)] = $object;
            }
        }
    }	// end selection mapping
    if ($jointsOrLocators == 0) {
        return $roots;
    } else {
        return $locators;
    }
}

// determines if the fk ik or bind skeletons 'appear' to have a conflicting name
proc warnRootSelections(string $fkRoot, string $ikRoot, string $bindRoot) {
    string $matched;
    $matched = `match "ik" (tolower($fkRoot))`;
    if (size($matched) > 0) { warning "You may have selected the IK skeleton as the FK root!"; } 
    $matched = `match "bind" (tolower($fkRoot))`;
    if (size($matched) > 0) { warning "You may have selected the Bind skeleton as the FK root!"; }
    $matched = `match "fk" (tolower($ikRoot))`;
    if (size($matched) > 0) { warning "You may have selected the FK skeleton as the IK root!"; }
    $matched = `match "bind" (tolower($ikRoot))`;
    if (size($matched) > 0) { warning "You may have selected the Bind skeleton as the IK root!"; }
    $matched = `match "fk" (tolower($bindRoot))`;
    if (size($matched) > 0) { warning "You may have selected the FK skeleton as the Bind root!"; }
    $matched = `match "ik" (tolower($bindRoot))`;
    if (size($matched) > 0) { warning "You may have selected the IK skeleton as the Bind root!"; }
}

// determines whether a string contains a substring with the option of case sensitivity
proc int stringContains(string $string, string $contains, int $caseSensitive) {
    string $matched;
    if ($caseSensitive) {
        $matched = `match $contains $string`;
    } else {
        $matched = `match (tolower($contains)) (tolower($string))`;
    }
    if (size($matched) > 0) {
        return 1;
    } else {
        return 0;
    }
}


//######################################################################################
//# ARMS
//######################################################################################
global proc string modRigLayoutArmSkeleton(int $left) {
    string $prefix, $missing[], $group;
    int $numOfArms, $i;
    
    $numOfArms = `intFieldGrp -q -v1 armNumOfArms`;
    
    if ($left) { print ("Laying out " + $numOfArms + " left arm(s)...\n"); }
    else { print ("Laying out " + $numOfArms + " right arm(s)...\n"); }
    
    // for each arm create a group of locators to indicate joints
    for ($i=1; $i<=$numOfArms; $i++) {
        if ($left) {
            $group = createLocGroup(("Arm"), {"shoulder", "elbow", "wrist", "collar", "armPoleVector"}, {2.0,17,0,  6,17,-0.5, 10,17,0,  1,16,0, 6,17,-4.5}, 0.8);
        } else {
            $group = createLocGroup(("Arm"), {"shoulder", "elbow", "wrist", "collar", "armPoleVector"}, {-2.0,17,0,  -6,17,-0.5, -10,17,0,  -1,16,0, -6,17,-4.5}, 0.8);
        }
        
        // Create a locator for the up vector of a joint...
        if ($left) {
            createLoc("elbowUpVector", ($group + "|elbow"), {6.0,18,-0.5}, 0.4);
            createLoc("xCollarVector", ($group + "|collar"), {1.0, 17, 0}, 0.2);
            createLoc("yCollarVector", ($group + "|collar"), {2.0, 16, 0}, 0.2);
        } else {
            createLoc("elbowUpVector", ($group + "|elbow"), {-6.0,18,-0.5}, 0.4);
            createLoc("xCollarVector", ($group + "|collar"), {-1.0, 17, 0}, 0.2);
            createLoc("yCollarVector", ($group + "|collar"), {-2.0, 16, 0}, 0.2);
        }
    }
    
    select -r $group;
    return $group;
}

global proc string[] modRigPreBuildArmSkeleton(string $roots[], string $locs[], int $left, string $biped) {
    string $locs[], $roots[], $object, $missing[], $arms[], $bindSkel[];
    int $i, $numOfSkelsToCreate;
    
    // Check that if only FK, IK or only Bind is checked then ensure that only 1 root is selected...
    // if more than one is checked then ensure that at least 1 and no more than 3 roots are selected...
    $numOfSkelsToCreate = `checkBoxGrp -q -v1 armFkIkCheckBox` + `checkBoxGrp -q -v2 armFkIkCheckBox` + `checkBoxGrp -q -v3 armFkIkCheckBox`;
    
    if (size($roots) > 3) { error "Too many root joints selected. The maximum is 3."; }
    
    if ($numOfSkelsToCreate == 0) {
        error "No Skeletons to create...";
    } else if ($numOfSkelsToCreate == 1 && size($roots) > 1) {
        error "Too many root joints selected";
    } else if ($numOfSkelsToCreate == 3 && size($roots) == 2) {
        error "To create IK, FK and Bind skeletons you must have 0, 1 or 3 roots selected, not 2.";
    }

    // Check that all locators are present to create a arm
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    // check that all the locators required for an arm are present
    for ($i=0; $i<size($locs); $i++) {
        print ("Checking validity of " + $locs[$i] + "...\n");
        $missing = checkLoc({$locs[$i]+"|shoulder", $locs[$i]+"|elbow", $locs[$i]+"|elbow|elbowUpVector", $locs[$i]+"|armPoleVector", $locs[$i]+"|wrist", $locs[$i]+"|collar", $locs[$i]+"|collar|xCollarVector", $locs[$i]+"|collar|yCollarVector"});
        if (size($missing) > 0) {
            reportMissing($missing,$locs[$i],0);
        } else {
            $arms[size($arms)] = $locs[$i];
        }
    }
    if (size($arms) > 0) {
        // create the arm
        $bindSkel = modRigBuildArmSkeleton($roots, $arms, $left, $biped);
    }
    return $bindSkel;
}

// creates the required amount of 'extra' locators for mid joints - used for the biceps and forearms on the bind arm
proc string[] createMidJoints(string $startName, string $endName, int $numOfMidJoints, string $parent) {
    float $startLoc[], $endLoc[], $deltaJoint[];
    string $midjoints[];
    // determine start and end ws points
    $startLoc = `xform -q -ws -rp $startName`;
    $endLoc = `xform -q -ws -rp $endName`;
    // determine the distance for each bicep to be offset
    $deltaJoint[0] = ($endLoc[0] - $startLoc[0])/(float)($numOfMidJoints +1);
    $deltaJoint[1] = ($endLoc[1] - $startLoc[1])/(float)($numOfMidJoints +1);
    $deltaJoint[2] = ($endLoc[2] - $startLoc[2])/(float)($numOfMidJoints +1);
    // for num of biceps loc = (elbow loc - shoulder loc) / num biceps
    for ($j=0; $j<$numOfMidJoints; $j++) {
        $temp = `spaceLocator -n "midjoint#"`;
        $temp[0] = "|" + $temp[0];
        move -a ($deltaJoint[0]*($j+1) +$startLoc[0]) ($deltaJoint[1]*($j+1) +$startLoc[1]) ($deltaJoint[2]*($j+1) +$startLoc[2]) $temp[0];
        //print ("Parenting " + $temp[0] + " to " + $parent + "\n");
        parent $temp[0] $parent;
        $midjoints[$j] = $parent + "|" + $temp[0];
    }
    return $midjoints;
}

// Tests to see if an object has an input connnection to a particular attribute and if so then break the connection
proc breakConnections(string $object, string $attribute) {
    string $source;
    if (`connectionInfo -isDestination ($object + "." + $attribute)`) {
        $source = `connectionInfo -sourceFromDestination ($object + "." + $attribute)`;
        disconnectAttr $source ($object + "." + $attribute);
    }
}

// Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley (with blending)
proc createTwistExpression(string $skelFK[], string $skelIK[], string $skelBind[], string $skelBindBase[], int $numOfBiceps, int $numOfForearms) {
    string $bicepExp, $forearmExp;
    for ($j=0; $j<$numOfBiceps; $j++) {
        $bicepExp = $bicepExp + $skelBind[2+$j] + ".rotateX = ((" + $skelFK[1] + ".rotateX * $FKinf) + (" + $skelIK[1] + ".rotateX * $IKinf))/" + $numOfBiceps + ";\n";
    }
    for ($j=0; $j<$numOfForearms; $j++) {
        $forearmExp = $forearmExp + $skelBind[2+$numOfBiceps+1+$j] + ".rotateX = ((" + $skelFK[3] + ".rotateX * $FKinf) + (" + $skelIK[3] + ".rotateX * $IKinf))/" + $numOfForearms + ";\n";
    }
    $exp = "// calculate the fk and ik influence based on blend\nfloat $FKinf = 1-(" + $skelBindBase[0] + ".blend_fk_ik/10);\nfloat $IKinf = (" + $skelBindBase[0] + ".blend_fk_ik/10);\n// Calculate the bicep x rotation\n" + $bicepExp + "// Calculate the forearm x rotation\n" + $forearmExp;
    expression -s $exp -o "" -ae 1 -uc all;
}

// Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley (without blending)
proc createTwistExpressionNoBlend(string $skel[], string $skelBind[], int $numOfBiceps, int $numOfForearms) {
    string $bicepExp, $forearmExp;
    for ($j=0; $j<$numOfBiceps; $j++) {
        $bicepExp = $bicepExp + $skelBind[2+$j] + ".rotateX = " + $skel[1] + ".rotateX/" + $numOfBiceps + ";\n";
    }
    for ($j=0; $j<$numOfForearms; $j++) {
        $forearmExp = $forearmExp + $skelBind[2+$numOfBiceps+1+$j] + ".rotateX = " + $skel[3] + ".rotateX/" + $numOfForearms + ";\n";
    }
    $exp = "// Calculate the bicep x rotation\n" + $bicepExp + "// Calculate the forearm x rotation\n" + $forearmExp;
    expression -s $exp -o "" -ae 1 -uc all;
}

// Create IK handles and pole vector for the arm
proc createArmIKHandles(string $skelIK[], string $poleVecLoc, string $ikRoot, int $left, string $biped) {
    string $ikHandle[], $group, $parented[];
    float $loc[], $ikSelOffset[] = {0,-2,0};
    
    $ikHandle = `ikHandle -sj $skelIK[1] -ee $skelIK[3] -p 1 -w 1 -n "ikArmHandle#"`;
    
    // pole vector
    poleVectorConstraint $poleVecLoc $ikHandle[0];
    // colour code the pole vec
    colourObjectWithColour($poleVecLoc, 2);
    // remove pole vector channels
    removeChannels({$poleVecLoc}, {"rx","ry","rz","sx","sy","sz"}, 1);
    // remove IK attributes
    removeChannels(removeElementAtIndex($skelIK, 0), {"tx","ty","tz","rx","ry","rz","sx","sy","sz"}, 0);
    
    // group the ikHandle
    $group = `group -em -n "ikArm#"`;
    // colour code the group
    colourObjectWithColour($group, 2);
    // move group pivot point to the ikHandle pivot point
    $loc = `xform -q -ws -rp $ikHandle[0]`;
    xform -ws -rp $loc[0] $loc[1] $loc[2] -sp $loc[0] $loc[1] $loc[2] $group;
    $parented = `parent $ikHandle[0] $group`;
    // rotate the group to match the wrist
    
    // make the group drive the wrist rotation
    //connectAttr -f ikArm1.rotate IK_L_wrist_1.rotate;
    
    //parent and freeze transform
    $parented = `parent $group $biped`;
    makeIdentity -apply true -t 1 -r 1 -s 1 $parented[0];
    toggleSelectionHandleWithOffset($parented[0], $ikSelOffset);
    
    $parented = `parent $poleVecLoc $ikRoot`;
    makeIdentity -apply true -t 1 $parented[0];
    toggleSelectionHandle($parented[0]);
    
    if ($left) {
        $ikSelOffset = {0,0,2};
    } else {
        $ikSelOffset = {0,0,-2};
    }
    toggleSelectionHandleWithOffset($skelIK[0], $ikSelOffset);
}

// adds an extra joint on the end (of the fk and ik arms) to help indicate the rotations of the arms by scaling the joint in one axis
proc addRotIndicationJoint(string $skelFK[], int $selHandle, int $left) {
    float $vec[], $secLast[], $last[], $temp[];
    string $joint;
    
    $secLast = `xform -q -ws -rp $skelFK[size($skelFK)-2]`;
    $last = `xform -q -ws -rp $skelFK[size($skelFK)-1]`;

    // get the vector from the second last to the last joint
    $vec = vecSub($last, $secLast);
    normalize($vec);
    
    // create our new joint offset from the last joint in the direction of vec
    //$joint = `joint -p ($vec[0]*0.5 + $last[0]) ($vec[1]*0.5 + $last[1]) ($vec[2]*0.5 + $last[2]) -n "RotIndication#"`;
    $joint = `joint -p ($vec[0]*0.5 + $last[0]) $last[1] $last[2] -n "RotIndication#"`;
    
    // scale the joint in only Z
    setAttr ($skelFK[size($skelFK)-1] + ".scaleZ") 4;

    parent $joint $skelFK[size($skelFK)-1];
    
    // add selection handle?
    if ($selHandle) {
        if ($left == 1) {
            toggleSelectionHandleWithOffset($skelFK[size($skelFK)-1], {0.0,0,-0.2});
        } else {
            toggleSelectionHandleWithOffset($skelFK[size($skelFK)-1], {0.0,0,0.2});
        }
    }
}
            
            
global proc string[] modRigBuildArmSkeleton(string $roots[], string $arms[], int $left, string $biped) {
    // Declare some variables
    string $skelFK[], $skelFK2[], $skelIK[], $skelIK2[], $skelBind[], $skelBindBase[], $skelBindBase2[], $biceps[], $forearms[], $fullBindLocators[];
    string $prefix, $ikHandles[], $temp[], $bicepExp, $forearmExp, $exp, $extraNaming;
    string $fkRoot, $ikRoot, $bindRoot, $poleVectorLoc, $ikGroup;
    
    float $upVector[], $upVectors[], $initialFKIKBlend, $upVectorLoc[], $upVectorLocRef[], $startJoint[], $endJoint[], $deltaJoint[];
    
    int $i, $j, $numOfArms, $numOfBiceps, $numOfForearms, $createSkels[], $templateSkels[], $hideSkels[];
    
    string $remFKAttrs[] = {"tx","ty","tz","sx","sy","sz"};
    string $remAllAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};
    float $bindSelOffset[] = {3,1,0};
    
    //Initialise variables from the GUI
    $numOfBiceps = `intFieldGrp -q -v1 armNumOfBiceps`;
    $numOfForearms = `intFieldGrp -q -v1 armNumOfForearms`;
    $createSkels[0] = `checkBoxGrp -q -v1 armFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 armFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 armFkIkCheckBox`;
    $initialFKIKBlend = `radioButtonGrp -q -sl armFkIkInitialBlend` == 1 ? 0 : 10;
    
    // prefix contains the group name with a pipe for easy naming of locators etc...
    $prefix = $arms[0] + "|";
    
    // If there is no joint selected, create root joint at first shoulder locator
    if (size($roots) < 1) {
        select -cl;
        warning "No root node selected. Creating a root joint at world 0...\n";
        $fkRoot = $ikRoot = $bindRoot = `joint -p 0 0 0 -n "chest"`;
    } else if (size($roots) == 1) {
        $fkRoot = $ikRoot = $bindRoot = $roots[0];
    } else if (size($roots) == 2) {
        if ($createSkels[0]) {
            $fkRoot = $roots[0];
            if ($createSkels[1]) {
                $ikRoot = $roots[1];
            } else {
                $bindRoot = $roots[1];
            }
        } else {
            $ikRoot = $roots[0];
            $bindRoot = $roots[1];
        }
    } else if (size($roots) == 3) {
        $fkRoot = $roots[0];
        $ikRoot = $roots[1];
        $bindRoot = $roots[2];
    }
    
    if ($left == 1) {
        $extraNaming = "L_";
        $ikSelOffset = {0,0,2};
    } else if ($left == 0) {
        $extraNaming = "R_";
    } else {
        $extraNaming = "";
    }
    
    // Build required skeleton and options for each arm
    for ($i=0; $i<size($arms); $i++) {
        print ("Creating arm " + $arms[$i] + "...\n");
        // prefix helps in the naming of each locator...
        $prefix = $arms[$i] + "|";
        // Up vector loc grabs the world pos of the upvector locator
        $upVectorLoc = `xform -q -ws -rp ($prefix + "elbow|elbowUpVector")`;
        // Up vector loc ref grabs the world pos of the locator to base the upvector loc from
        $upVectorLocRef = `xform -q -ws -rp ($prefix+"elbow")`;
        $upVector = vecSub($upVectorLoc, $upVectorLocRef);
        normalize($upVector);
        
        // parent poleVectorLoc to the world (so it doesn't get deleted when the arm locator group gets deleted
        $temp = `parent -w ($prefix+"armPoleVector")`;
        $poleVecLoc = $temp[0];
        
        if ($createSkels[0]) {
            // Create the FK skelton from the shoulder...
            $skelFK = skelAtLoc($fkRoot, {$prefix+"collar",$prefix+"shoulder", $prefix+"elbow", $prefix+"wrist"}, $upVector, "FK_"+$extraNaming);
            if (size($skelFK) != 4) { error "Number of expected joints on skelFK does not equal 4.\n"; }
            // orient the collar bone to the collar bone aim and up locators
            orientToLocators($skelFK[0], $prefix+"collar|xCollarVector", $prefix+"collar|yCollarVector");
            addRotIndicationJoint($skelFK, 0, $left);
            // lock and remove FK attributes
            removeChannels($skelFK, $remFKAttrs, 1);
            // remove rx and rz from the elbow
            removeChannels({$skelFK[2]}, {"rx","rz"}, 1);
            // add selection handles to every joint
            toggleSelectionHandles($skelFK);
            // colour code
            colourObjectWithColour($skelFK[0], 1);
            // If FK is selected but not IK and size of roots is 3 then we create 2 FK skeletons...
            if ($createSkels[1] == 0 && size($roots) == 3) {
                $skelFK2 = skelAtLoc($ikRoot, {$prefix+"collar",$prefix+"shoulder", $prefix+"elbow", $prefix+"wrist"}, $upVector, "FK_"+$extraNaming);
                if (size($skelFK2) != 4) { error "Number of expected joints on skelFK2 does not equal 4.\n"; }
                // orient the collar bone to the collar bone aim and up locators
                orientToLocators($skelFK2[0], $prefix+"collar|xCollarVector", $prefix+"collar|yCollarVector");
                addRotIndicationJoint($skelFK2, 0, $left);
                // lock and remove FK attributes
                removeChannels($skelFK2, $remFKAttrs, 1);
                // remove rx and rz from the elbow
                removeChannels({$skelFK[2]}, {"rx","rz"}, 1);
                // add selection handles to every joint
                toggleSelectionHandles($skelFK2);
                // colour code
                colourObjectWithColour($skelFK2[0], 1);
            }
        }
        
        if ($createSkels[1]) {
            // Create the IK skelton from the shoulder...
            $skelIK = skelAtLoc($ikRoot, {$prefix+"collar",$prefix+"shoulder", $prefix+"elbow", $prefix+"wrist"}, $upVector, "IK_"+$extraNaming);
            if (size($skelIK) != 4) { error "Number of expected joints on skelIK does not equal 4.\n"; }
            // orient the collar bone to the collar bone aim and up locators
            orientToLocators($skelIK[0], $prefix+"collar|xCollarVector", $prefix+"collar|yCollarVector");
            // Create IK handles and pole vector for the arm
            createArmIKHandles($skelIK, $poleVecLoc, $ikRoot, $left, $biped);
            addRotIndicationJoint($skelIK, 0, $left);
            // colour code
            colourObjectWithColour($skelIK[0], 2);
            
            // if IK is selected but not FK and size of roots is 3 then we create 2 IK skels
            if ($createSkels[0] == 0 && size($roots) == 3) {
                $skelIK2 = skelAtLoc($fkRoot, {$prefix+"collar",$prefix+"shoulder", $prefix+"elbow", $prefix+"wrist"}, $upVector, "IK_"+$extraNaming);
                if (size($skelIK2) != 4) { error "Number of expected joints on skelIK2 does not equal 4.\n"; }
                // orient the collar bone to the collar bone aim and up locators
                orientToLocators($skelIK2[0], $prefix+"collar|xCollarVector", $prefix+"collar|yCollarVector");
                // Create IK handles and pole vector for the arm
                createArmIKHandles($skelIK2, $poleVecLoc, $fkRoot, $left, $biped);
                addRotIndicationJoint($skelIK2, 0, $left);
                // colour code
                colourObjectWithColour($skelIK2[0], 2);
            }
        }
        
        if ($createSkels[2]) {
            // Create the Bind skeleton from the shoulder...
            // Create Locators for the Biceps...
            $biceps = createMidJoints(($prefix+"shoulder"), ($prefix+"elbow"), $numOfBiceps, $arms[$i]);
            // Create Locators for the Forearms...
            $forearms = createMidJoints(($prefix+"elbow"), ($prefix+"wrist"), $numOfForearms, $arms[$i]);
            // Create a string array containing all the locators on the bind skeleton...
            $fullBindLocators = {$prefix+"collar",$prefix+"shoulder"};
            appendStringArray($fullBindLocators, $biceps, size($biceps));
            appendStringArray($fullBindLocators, {$prefix+"elbow"}, 1);
            appendStringArray($fullBindLocators, $forearms, size($forearms));
            appendStringArray($fullBindLocators, {$prefix+"wrist"}, 1);
            $skelBind = skelAtLoc($bindRoot, $fullBindLocators, $upVector, "BIND_"+$extraNaming);
            // orient the collar bone to the collar bone aim and up locators
            orientToLocators($skelBind[0], $prefix+"collar|xCollarVector", $prefix+"collar|yCollarVector");
            if (size($skelBind) != 4+$numOfBiceps+$numOfForearms) { error ("Number of expected joints on skelBind does not equal " + 4+$numOfBiceps+$numOfForearms + ".\n"); }
            // Delete the bicep locators
            for ($j=0; $j<size($biceps); $j++) { delete $biceps[$j]; }
            // Delete the forearm locators
            for ($j=0; $j<size($forearms); $j++) { delete $forearms[$j]; }
            // Create a variable of the Bind skeleton that removes any bicep or forearm for the blend expression...
            $skelBindBase = {$skelBind[0], $skelBind[1], $skelBind[$numOfBiceps+2], $skelBind[$numOfBiceps+2+$numOfForearms+1]};
            // remove all channel attributes from the bind skel
            removeChannels($skelBind, $remAllAttrs, 0);
            // add selection handle to blend joint
            toggleSelectionHandleWithOffset($skelBind[0], $bindSelOffset);
            // colour code
            colourObjectWithColour($skelBind[0], 3);
//            addVisibilityAttributes($skelBind[0], {$skelIK
        }
        
        // Create orient contraints between FK, IK and Bind skeletons
        // Create blending of weights or direct connections
        if ($createSkels[0] && $createSkels[1] && $createSkels[2]) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelIK, $skelFK, $skelBindBase, $initialFKIKBlend, 0);
            // Break the X connections on the shoulder and wrist
            breakConnections($skelBindBase[1], "rx");
            breakConnections($skelBindBase[3], "rx");
            // Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley
            createTwistExpression($skelFK, $skelIK, $skelBind, $skelBindBase, $numOfBiceps, $numOfForearms);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) == 3) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelFK, $skelFK2, $skelBindBase, $initialFKIKBlend, 0);
            // Break the X connections on the shoulder and wrist
            breakConnections($skelBindBase[1], "rx");
            breakConnections($skelBindBase[3], "rx");
            // Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley
            createTwistExpression($skelFK, $skelFK2, $skelBind, $skelBindBase, $numOfBiceps, $numOfForearms);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelFK, $skelBindBase);
            // Break the X connections on the shoulder and wrist
            breakConnections($skelBindBase[1], "rx");
            breakConnections($skelBindBase[3], "rx");
            // Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley
            createTwistExpressionNoBlend($skelFK, $skelBind, $numOfBiceps, $numOfForearms);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) == 3) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelIK, $skelIK2, $skelBindBase, $initialFKIKBlend, 0);
            // Break the X connections on the shoulder and wrist
            breakConnections($skelBindBase[1], "rx");
            breakConnections($skelBindBase[3], "rx");
            // Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley
            createTwistExpression($skelIK, $skelIK2, $skelBind, $skelBindBase, $numOfBiceps, $numOfForearms);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelIK, $skelBindBase);
            // Break the X connections on the shoulder and wrist
            breakConnections($skelBindBase[1], "rx");
            breakConnections($skelBindBase[3], "rx");
            // Create expression to control the twisting of the biceps and forarms based on the shoulder x rotation and the wrist x rotation respectivley
            createTwistExpressionNoBlend($skelIK, $skelBind, $numOfBiceps, $numOfForearms);
        }
        
        // delete the locators
        delete $arms[$i];
        
        // Template and hide the required skels
        if ($createSkels[0] && $templateSkels[0]) { toggle -state on -te $skelFK[0]; }
        if ($createSkels[1] && $templateSkels[1]) { toggle -state on -te $skelIK[0]; }
        if ($createSkels[2] && $templateSkels[2]) { toggle -state on -te $skelBind[0]; }
        if ($createSkels[0] && $hideSkels[0]) { hide $skelFK[0]; }
        if ($createSkels[1] && $hideSkels[1]) { hide $skelIK[0]; }
        if ($createSkels[2] && $hideSkels[2]) { hide $skelBind[0]; }
    }
    select -cl;
    return $skelBind;
}

//######################################################################################
//# FEET - LEGS
//######################################################################################
global proc string modRigLayoutReverseFootSkeleton(int $left) {
    string $prefix, $group;
    int $numOfLegs, $i;
    float $x;
    
    $numOfLegs = `intFieldGrp -q -v1 legNumOfLegs`;
    
    if ($left) { print ("Laying out " + $numOfLegs + " left leg(s)...\n"); }
    else { print ("Laying out " + $numOfLegs + " right leg(s)...\n"); }
    
    // for each leg create a group of locators to indicate joints
    // Need to check if there is already legs locators already out there***********
    for ($i=1; $i<=$numOfLegs; $i++) {
        if ($left) {
            $x = 2.0;
        } else {
            $x = -2.0;
        }
        $group = createLocGroup(("Leg"), {"hip", "knee", "ankle", "arch", "ball", "toe", "heel", "legPoleVector"}, {$x,9,0,  $x,5,0.3,  $x,1,0,  $x,0,1,  $x,0,2,  $x,0,2.5,  $x,0,0,  $x,5,5}, 1);
        // Create a locator for the up vector of a joint...
        createLoc("kneeUpVector", ($group+"|knee"), {$x,5,1}, 0.4);
        createLoc("footUpVector", ($group+"|heel"), {$x,1,1}, 0.4);
    }
    select -r $group;
    return $group;
}

global proc string modRigPreBuildReverseFootSkeleton(string $roots[], string $locs[], int $left) {
    string $locs[], $roots[], $object, $missing[], $legs[], $return;
    int $i, $numOfSkelsToCreate;
    
    // Check that if only FK, IK or only Bind is checked then ensure that only 1 root is selected...
    // if more than one is checked then ensure that at least 1 and no more than 3 roots are selected...
    $numOfSkelsToCreate += `checkBoxGrp -q -v1 legFkIkCheckBox` + `checkBoxGrp -q -v2 legFkIkCheckBox` + `checkBoxGrp -q -v3 legFkIkCheckBox`;
    
    if (size($roots) > 3) { error "Too many root joints selected. The maximum is 3."; }
    if ($numOfSkelsToCreate == 0) {
        error "No Skeletons to create...";
    } else if ($numOfSkelsToCreate == 1 && size($roots) > 1) {
        error "Too many root joints selected";
    } else if ($numOfSkelsToCreate == 3 && size($roots) == 2) {
        error "To create IK, FK and Bind skeletons you must have 0, 1 or 3 roots selected, not 2.";
    }
    
    // Check that all locators are present to create a foot/leg
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    for ($i=0; $i<size($locs); $i++) {
        print ("Checking validity of " + $locs[$i] + "...\n");
        $missing = checkLoc({$locs[$i]+"|hip", $locs[$i]+"|knee", $locs[$i]+"|knee|kneeUpVector", $locs[$i]+"|ankle", $locs[$i]+"|arch", $locs[$i]+"|ball", $locs[$i]+"|toe", $locs[$i]+"|heel", $locs[$i]+"|legPoleVector", $locs[$i]+"|heel|footUpVector"});
        if (size($missing) > 0) {
            reportMissing($missing, $locs[$i], 0);           
        } else {
            $legs[size($legs)] = $locs[$i];
        }
    }
    if (size($legs) > 0) {
        $return = modRigBuildReverseFootSkeleton($roots, $legs, $left);
    }
    return $return;
}

// Creates the IK handles for the reverse foot and parent the handles to the IK leg
proc createReverseFootIKHandles(string $skelIK[], string $heelSkel[], string $poleVecLoc) {
    string $temp[];
    // create ik between hip and ankle
    $temp = `ikHandle -sj $skelIK[0] -ee $skelIK[2] -p 1 -w 1`;
    $ikHandles[0] = $temp[0];
    
    // add pole vector to the knee
    poleVectorConstraint $poleVecLoc $ikHandles[0];
    removeChannels({$poleVecLoc}, {"rx","ry","rz","sx","sy","sz"}, 1);
    // colour code the pole vec
    colourObjectWithColour($poleVecLoc, 2);
    
    // add ik to the foot
    $temp = `ikHandle -sj $skelIK[2] -ee $skelIK[4] -p 1 -w 1`;
    $ikHandles[1] = $temp[0];
    $temp = `ikHandle -sj $skelIK[4] -ee $skelIK[5] -p 1 -w 1`;
    $ikHandles[2] = $temp[0];
        
    // Parent them to the appropriate bone on the heel control skeleton
    parent $ikHandles[0] $heelSkel[4];
    parent $ikHandles[1] $heelSkel[2];
    parent $ikHandles[2] $heelSkel[1];
    parent $poleVecLoc $heelSkel[0];
    
    // freeze transforms on the pole vector and toggle selection handles... need to do this AFTER the parenting
    makeIdentity -apply true -t 1 ($heelSkel[0] + "|" + $poleVecLoc);
    toggleSelectionHandle($heelSkel[0] + "|" + $poleVecLoc);
}

// Create the roll attribute for the reverse foot heel
proc createReverseFootRollKeys(string $heelSkel[], string $controlNode) {
    // Add the roll attribute to the control node
    addAttr -ln roll -at double -min -5 -max 5 -dv 0 $controlNode;
    setAttr -e -keyable true ($controlNode + ".roll");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv 0 -v 0 ($heelSkel[0] + ".rotateZ");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv (-5) -v (20) ($heelSkel[0] + ".rotateZ");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv 0 -v 0 ($heelSkel[2] + ".rotateZ");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv (5) -v (30) ($heelSkel[2] + ".rotateZ");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv 0 -v 0 ($heelSkel[1] + ".rotateZ");
    setDrivenKeyframe -cd ($controlNode + ".roll") -dv (5) -v (30) ($heelSkel[1] + ".rotateZ");
}

global proc string modRigBuildReverseFootSkeleton(string $roots[], string $legs[], int $left) {
    // Declare some variables...
    string $skelFK[], $skelFK2[], $skelIK[], $skelIK2[], $skelBind[], $skelBind2[], $heelSkel[], $heelSkel2[];
    string $prefix, $ikHandles[], $poleVecLoc, $temp[], $footGroup, $extraNaming;
    string $fkRoot, $ikRoot, $bindRoot;
    
    float $upVector[], $upVectors[], $reverseFootUpVectors[], $jointLoc[], $initialFKIKBlend, $upVectorLoc[], $upVectorLocRef[];
    
    int $i, $j, $numOfLegs, $createSkels[], $templateSkels[], $hideSkels[];
    
    string $remFKAttrs[] = {"tx","ty","tz","sx","sy","sz"};
    string $remAllAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};

    //Initialise variables from the GUI
    $createSkels[0] = `checkBoxGrp -q -v1 legFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 legFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 legFkIkCheckBox`;
    $initialFKIKBlend = `radioButtonGrp -q -sl legFkIkInitialBlend` == 1 ? 0 : 10;
    
    // prefix contains the group name with a pipe for easy naming of locators etc...
    $prefix = $legs[0] + "|";
    
    // If there is no joint selected, create root joint at first hip locator
    if (size($roots) < 1) {
        select -cl;
        warning "No root node selected. Creating a root joint at world 0...\n";
        $fkRoot = $ikRoot = $bindRoot = `joint -p 0 0 0 -n "tail"`;
    } else if (size($roots) == 1) {
        $fkRoot = $ikRoot = $bindRoot = $roots[0];
    } else if (size($roots) == 2) {
        if ($createSkels[0]) {
            $fkRoot = $roots[0];
            if ($createSkels[1]) {
                $ikRoot = $roots[1];
            } else {
                $bindRoot = $roots[1];
            }
        } else {
            $ikRoot = $roots[0];
            $bindRoot = $roots[1];
        }
    } else if (size($roots) == 3) {
        $fkRoot = $roots[0];
        $ikRoot = $roots[1];
        $bindRoot = $roots[2];
    }
    if ($left  == 1) {
        $extraNaming = "L_";
    } else if ($left == 0) {
        $extraNaming = "R_";
    } else {
        $extraNaming = "";
    }
    
    // Build required skeleton and options for each leg
    for ($i=0; $i<size($legs); $i++) {
        print ("Creating leg " + $legs[$i] + "...\n");
        // prefix helps in the naming of each locator...
        $prefix = $legs[$i] + "|";
        
        // parent poleVectorLoc to the world (so it doesn't get deleted when the leg locator group gets deleted
        $temp = `parent -w ($prefix+"legPoleVector")`;
        $poleVecLoc = $temp[0];
        
        // Up vector loc grabs the world pos of the upvector locator
        $upVectorLoc = `xform -q -ws -rp ($prefix + "knee|kneeUpVector")`;
        // Up vector loc ref grabs the world pos of the locator to base the upvector loc from
        $upVectorLocRef = `xform -q -ws -rp ($prefix+"knee")`;
        $upVector = vecSub($upVectorLoc, $upVectorLocRef);
        normalize($upVector);
        // Declare up vectors for the hip and knee
        for ($j=0; $j<9; $j++) {
            $upVectors[$j] = $upVector[$j%3];
        }
        // Up vector loc grabs the world pos of the upvector locator
        $upVectorLoc = `xform -q -ws -rp ($prefix + "heel|footUpVector")`;
        // Up vector loc ref grabs the world pos of the locator to base the upvector loc from
        $upVectorLocRef = `xform -q -ws -rp ($prefix+"heel")`;
        $upVector = vecSub($upVectorLoc, $upVectorLocRef);
        normalize($upVector);
        // Declare up vectors for the ankle, arch, ball and toe
        for ($j=9; $j<18; $j++) { $upVectors[$j] = $upVector[$j%3]; }
        for ($j=0; $j<15; $j++) { $reverseFootUpVectors[$j] = $upVector[$j%3]; }

        if ($createSkels[0]) {
            // Create the FK skelton from the hip down...
            $skelFK = skelAtLoc($fkRoot, {$prefix+"hip", $prefix+"knee", $prefix+"ankle", $prefix+"arch", $prefix+"ball", $prefix+"toe"}, $upVectors, "FK_"+$extraNaming);
            if (size($skelFK) != 6) { error "Number of expected joints on skelFK does not equal 6.\n"; }
            removeChannels($skelFK, $remFKAttrs, 1);
            // remove ry and rx from the knee
            removeChannels({$skelFK[1]}, {"rx","ry"}, 1);
            // remove the toe and heel from the array before we add the selection handles
            // add selection handles for each leg joint except the toe
            toggleSelectionHandles(removeElementAtIndex($skelFK,5));
            // colour code
            colourObjectWithColour($skelFK[0], 1);
            
            // If FK is selected but not IK and size of roots is 3 then we create 2 FK skeletons...
            if ($createSkels[1] == 0 && size($roots) == 3) {
            	$skelFK2 = skelAtLoc($ikRoot, {$prefix+"hip", $prefix+"knee", $prefix+"ankle", $prefix+"arch", $prefix+"ball", $prefix+"toe"}, $upVectors, "FK_"+$extraNaming);
                if (size($skelFK2) != 6) { error "Number of expected joints on skelFK2 does not equal 6.\n"; }
                removeChannels($skelFK2, $remFKAttrs, 1);
                // remove the toe from the array before we add the selection handles
                // add selection handles for each leg joint except the toe
                toggleSelectionHandles(removeElementAtIndex($skelFK2,5));
                // colour code
                colourObjectWithColour($skelFK2[0], 1);
            }
        }
        
        if ($createSkels[1]) {
            // Create the IK skelton from the hip down...
            $skelIK = skelAtLoc($ikRoot, {$prefix+"hip", $prefix+"knee", $prefix+"ankle", $prefix+"arch", $prefix+"ball", $prefix+"toe"}, $upVectors, "IK_"+$extraNaming);
            if (size($skelIK) != 6) { error "Number of expected joints on skelIK does not equal 6.\n"; }
            // remove IK attributes
            removeChannels($skelIK, $remAllAttrs, 0);
            // colour code
            colourObjectWithColour($skelIK[0], 2);
            
            $heelSkel = skelAtLoc("", {$prefix+"heel", $prefix+"toe", $prefix+"ball", $prefix+"arch", $prefix+"ankle"}, $reverseFootUpVectors, "IK_"+$extraNaming);
            if (size($heelSkel) != 5) { error "Number of expected joints on heelSkel does not equal 5.\n"; }
            // remove IK attributes
            removeChannels($heelSkel, $remAllAttrs, 0);
            // colour code
            colourObjectWithColour($heelSkel[0], 2);
                     
            // Create 3 IK handles and a pole vector for the reverse foot and parent to the heel skel
            createReverseFootIKHandles($skelIK,$heelSkel,$poleVecLoc);
            
            // add group to heel skel
            if ($left == 1) {
                $footGroup = `group -em -n "L_Foot"`;
            } else if ($left == 0) {
                $footGroup = `group -em -n "R_Foot"`;
            } else {
                $footGroup = `group -em -n "Foot"`;
            }
            //colour code the foot group
            colourObjectWithColour($footGroup, 2);
            
            // move the pivot point of the foot to the heel pivot point
            $jointLoc = `xform -q -ws -rp $heelSkel[0]`;
            xform -ws -rp $jointLoc[0] $jointLoc[1] $jointLoc[2] $footGroup;
                
            // toggle selection handle
            toggleSelectionHandle($footGroup);  
            
            // set the roll driven key to drive the heel rotation
            createReverseFootRollKeys($heelSkel, $footGroup);
            parent $heelSkel[0] $footGroup;
            print ("Foot group inside build: " + $footGroup + "\n");
            // if IK is selected but not FK and size of roots is 3 then we create 2 IK skels
            if ($createSkels[0] == 0 && size($roots) == 3) {
                // Create the IK skelton from the hip down...
                $skelIK2 = skelAtLoc($fkRoot, {$prefix+"hip", $prefix+"knee", $prefix+"ankle", $prefix+"arch", $prefix+"ball", $prefix+"toe"}, $upVectors, "IK_"+$extraNaming);
                if (size($skelIK2) != 6) { error "Number of expected joints on skelIK2 does not equal 6.\n"; }
                // remove IK attributes
                removeChannels($skelIK2, $remAllAttrs, 0);
                // colour code
                colourObjectWithColour($skelIK2[0], 2);
                
                $heelSkel2 = skelAtLoc("", {$prefix+"heel", $prefix+"toe", $prefix+"ball", $prefix+"arch", $prefix+"ankle"}, $reverseFootUpVectors, "IK_"+$extraNaming);
                if (size($heelSkel2) != 5) { error "Number of expected joints on heelSkel2 does not equal 5.\n"; }
                // remove IK attributes
                removeChannels($heelSkel2, $remAllAttrs, 0);
                // colour code
                colourObjectWithColour($heelSkel2[0], 2);
                
                // Create 3 IK handles and a pole vector for the reverse foot and parent to the heel skel
               	createReverseFootIKHandles($skelIK2,$heelSkel2,$poleVecLoc);
               	
                // add group to heel skel
                if ($left == 1) {
                    $footGroup = `group -em -n "L_Foot"`;
                } else if ($left == 0) {
                    $footGroup = `group -em -n "R_Foot"`;
                } else {
                    $footGroup = `group -em -n "Foot"`;
                    }
                //colour code the foot group
                colourObjectWithColour($footGroup, 2);
                
                // move the pivot point of the foot to the heel pivot point
                $jointLoc = `xform -q -ws -rp $heelSkel2[0]`;
                xform -ws -rp $jointLoc[0] $jointLoc[1] $jointLoc[2] $footGroup;
                
                // toggle selection handle
                toggleSelectionHandle($footGroup);
            
                // set the roll driven key to drive the heel rotation
                createReverseFootRollKeys($heelSkel2, $footGroup);
                parent $heelSkel2[0] $footGroup;
            }
        }
        
        if ($createSkels[2]) {
            // Create the Bind skeleton from the hip down...
            $skelBind = skelAtLoc($bindRoot, {$prefix+"hip", $prefix+"knee", $prefix+"ankle", $prefix+"arch", $prefix+"ball", $prefix+"toe"}, $upVectors, "BIND_"+$extraNaming);
            if (size($skelBind) != 6) { error "Number of expected joints on skelBind does not equal 6.\n"; }
            // remove all channel attributes from the bind skel
            removeChannels($skelBind, $remAllAttrs, 0);
            // add selection handle to blend joint
            toggleSelectionHandleWithOffset($skelBind[0], {0.0,-2,0});
            // colour code
            colourObjectWithColour($skelBind[0], 3);
        }
        
        // Create orient contraints between FK, IK and Bind skeletons
        // Create blending of weights or direct connections
        if ($createSkels[0] && $createSkels[1] && $createSkels[2]) {
            buildIKFKBlend($skelIK, $skelFK, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) == 3) {
            buildIKFKBlend($skelFK, $skelFK2, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelFK, $skelBind);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) == 3) {
            buildIKFKBlend($skelIK, $skelIK2, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelIK, $skelBind);
        }
        // delete the locators
        delete $legs[$i];
    
        // Template and hide the required skels
        if ($createSkels[0] && $templateSkels[0]) { toggle -state on -te $skelFK[0]; }
        if ($createSkels[1] && $templateSkels[1]) { toggle -state on -te $skelIK[0]; }
        if ($createSkels[2] && $templateSkels[2]) { toggle -state on -te $skelBind[0]; }
        if ($createSkels[0] && $hideSkels[0]) { hide $skelFK[0]; }
        if ($createSkels[1] && $hideSkels[1]) { hide $skelIK[0]; }
        if ($createSkels[2] && $hideSkels[2]) { hide $skelBind[0]; }
    }
    
    select -cl;
    return $footGroup;
}

//######################################################################################
//# HANDS
//######################################################################################
global proc string modRigLayoutHand(int $left) {
    string $prefix, $group, $fingerKnuckleNames[], $fingerTipNames[], $temp;
    float $deltaFinger, $X, $Y, $totSpread, $fingerKnuckles[], $fingerTips[];
    int $numOfFingers, $i, $upKnuckle, $thumb;
    
    $numOfFingers = `intFieldGrp -q -v1 handNumOfFingers`;
    $numOfHands = `intFieldGrp -q -v1 handNumOfHands`;
    $thumb = `checkBoxGrp -q -v1 handThumbCheckBox`;
    
    if ($thumb) { $temp = "a"; } else { $temp = "no"; }
    if ($left) { print ("Laying out " + $numOfHands + " left hand(s) with " + $numOfFingers + " fingers and " + $temp + " thumb...\n"); }
    else { print ("Laying out " + $numOfHands + " right hand(s) with " + $numOfFingers + " fingers and " + $temp + " thumb...\n"); }
    
    $deltaFinger = 0.2;
    $X = ($deltaFinger * ($numOfFingers-1 > 0 ? $numOfFingers-1 : 1) * 2);
    $Y = 0;
    $totSpread = $deltaFinger*($numOfFingers-1);
    // for each finger create a locator to indicate the tip of the finger
    for ($i=0; $i<$numOfHands; $i++) {        
        // position the finger tips
        for ($j=0; $j<$numOfFingers; $j++) {
            $fingerTipNames[$j] = ("fingerTip"+$j);
            $fingerTips[$j*3] = $left ? $X : -$X;
            $fingerTips[$j*3 + 1] = $Y;
            $fingerTips[$j*3 + 2] = (linstep(0,$numOfFingers-1,$j)-0.5)*$totSpread;
        }
        
        // position the main knuckles
        for ($j=0; $j<$numOfFingers; $j++) {
            $fingerKnuckleNames[$j] = ("fingerKnuckle"+$j);
            $fingerKnuckles[$j*3] = $left ? $X/2 : -$X/2;
            $fingerKnuckles[$j*3 + 1] = $Y;
            $fingerKnuckles[$j*3 + 2] = (linstep(0,$numOfFingers-1,$j)-0.5)*$totSpread;
        }
        
        if ($thumb) {
            //Position the thumb
            $fingerTipNames[$numOfFingers] = "thumbTip";
            $fingerTips[$numOfFingers*3] = $left ? $X/2 : -$X/2;
            $fingerTips[$numOfFingers*3+1] = $Y-$deltaFinger;
            $fingerKnuckleNames[$numOfFingers] = "thumbKnuckle";
            $fingerKnuckles[$numOfFingers*3] = $left ? $X/4 : -$X/4;
            $fingerKnuckles[$numOfFingers*3+1] = $Y-$deltaFinger;
            $fingerKnuckles[$numOfFingers*3+2] = $fingerTips[$numOfFingers*3+2] = $totSpread/2 + $deltaFinger;
        }
        
        $group = createLocGroupTree("Hand", $fingerKnuckleNames, $fingerTipNames, $fingerKnuckles, $fingerTips, 0.15);
        
        // Create a locator for the ridge joint...
        if ($numOfFingers%2==1) {
            if ($left) {
                createLoc("ridge", $group, {$X/3,$Y,0}, 0.1);
            } else {
                createLoc("ridge", $group, {-$X/3,$Y,0}, 0.1);
            }
        } else {
            if ($left) {
                createLoc("ridge", $group, {$X/3,$Y,$deltaFinger/2}, 0.1);
            } else {
                createLoc("ridge", $group, {-$X/3,$Y,$deltaFinger/2}, 0.1);
            }
        }
        
        // Create a locator for the wrist joint...
        createLoc("wrist", $group, {0.0,$Y,0}, 0.1);
        
        // Create a locator for the up vector of a joint...
        if ($left) {
            createLoc("fingerKnuckleUpVector", ($group+"|fingerKnuckle0"), {$X/2,$Y+0.2,$fingerKnuckles[2]}, 0.05);
            if ($thumb) { createLoc("thumbUpVector", ($group+"|thumbKnuckle"), {$X/4,$Y-$deltaFinger,$totSpread/2+$deltaFinger*2}, 0.05); }
        } else {
            createLoc("fingerKnuckleUpVector", ($group+"|fingerKnuckle0"), {-$X/2,$Y+0.2,$fingerKnuckles[2]}, 0.05);
            if ($thumb) { createLoc("thumbUpVector", ($group+"|thumbKnuckle"), {-$X/4,$Y-$deltaFinger,$totSpread/2+$deltaFinger*2}, 0.05); }
        }
        if ($left) { setAttr ($group + ".tx") 10.5; } else { setAttr ($group + ".tx") -10.5; }
        setAttr ($group + ".ty") 17;
    }
    select -r $group;
    return $group;
}

global proc modRigPreBuildHand(string $roots[], string $locs[]) {
    string $knuckles[], $tips[], $hands[], $roots[];
    int $numOfSkelsToCreate, $tipExists, $i, $j, $k, $numOfFingers, $numOfRidges;    
    
    // Check that if only FK, IK or only Bind is checked then ensure that only 1 root is selected...
    // if more than one is checked then ensure that at least 1 and no more than 3 roots are selected...
    $numOfSkelsToCreate += `checkBoxGrp -q -v1 handFkIkCheckBox` + `checkBoxGrp -q -v2 handFkIkCheckBox` + `checkBoxGrp -q -v3 handFkIkCheckBox`;
    
    if (size($roots) > 3) { error "Too many root joints selected. The maximum is 3."; }
    if ($numOfSkelsToCreate == 0) {
        error "No Skeletons to create...";
    } else if ($numOfSkelsToCreate == 1 && size($roots) > 1) {
        error "Too many root joints selected";
    } else if ($numOfSkelsToCreate == 3 && size($roots) == 2) {
        error "To create IK, FK and Bind skeletons you must have 0, 1 or 3 roots selected, not 2.";
    }
    
    if (`checkBoxGrp -q -v2 handFkIkCheckBox`) { error "Do not support IK hands yet..."; }
    
    // Check that all locators are present to create a hand
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    for ($i=0; $i<size($locs); $i++) {
        print ("Checking validity of " + $locs[$i] + "...\n");
        //initialise some variables
        $numOfRidges = $numOfWrists = $numOfFingers = 0;
        // for each locator group, check that there is at least one finger
        $knuckles = `listRelatives $locs[$i]`;
        if (size($knuckles) < 1) { error "No fingers found in hand group."; }
        // for each finger
        for ($j=0; $j<size($knuckles); $j++) {
            // check that the name contains knuckle
            if (stringContains($knuckles[$j], "knuckle", 0) == 0 && stringContains($knuckles[$j], "ridge", 0) == 0 && stringContains($knuckles[$j], "wrist", 0) == 0) {
                error ("A child of " + $locs[$i] + " does not contain the word wrist, ridge or knuckle.");
            } else if (stringContains($knuckles[$j], "knuckle", 0)) {
                if (stringContains($knuckles[$j], "finger", 0)) {
                    // add a finger to the counter
                    $numOfFingers++;
                }
                // Check that a tip exists for each knuckle
                $tips = `listRelatives ($locs[$i] + "|" + $knuckles[$j])`;
                $tipExists = 0;
                for ($k=0; $k<size($tips); $k++) {
                    if (stringContains($tips[$k], "tip", 0)) {
                        $tipExists = 1;
                    }
                }
                if ($tipExists == 0) {
                    error ("The knuckle " + $knuckles[$j] + " does not contain a tip as its child.");
                }
            } else if (stringContains($knuckles[$j], "ridge", 0)) {
                // add a ridge to the counter
                $numOfRidges++;
            } else if (stringContains($knuckles[$j], "wrist", 0)) {
                // add a ridge to the counter
                $numOfWrists++;
            }
        }
        // if there is more or less than one ridge then barf
        if ($numOfRidges != 1) { error "There should be at least one and no more than one ridge locator."; }
        // if there is more or less than one wrist then barf
        if ($numOfWrists != 1) { error "There should be at least one and no more than one wrist locator."; }
        // if there is less than 1 finger then barf
        if ($numOfFingers < 1) { error "No fingers found in hand group."; }
        
        $hands[size($hands)] = $locs[$i];
    }
    // call the build hand
    modRigBuildHand($roots, $hands);
}


proc string getMidFinger(string $hand) {
    int $i, $index;
    string $knuckles[], $fingers[], $temp;
    $knuckles = `listRelatives -f $hand`;
    for ($i=0; $i<size($knuckles); $i++) {
        // check that the name contains finger
        if (stringContains($knuckles[$i], "finger", 0)) {
            $fingers[size($fingers)] = $knuckles[$i];
        }
    }
    if (stringContains($knuckles[0], "thumb", 0)) {
        return $fingers[(int)size($fingers)/2-1];
    } else {
        return $fingers[(int)size($fingers)/2];
    }
}

proc int getNumberOfFingers(string $hand) {
    int $i, $numOfFingers;
    string $knuckles[];
    $knuckles = `listRelatives $hand`;
    for ($i=0; $i<size($knuckles); $i++) {
        // check that the name contains finger
        if (stringContains($knuckles[$i], "finger", 0)) {
            $numOfFingers++;
        }
    }
    return $numOfFingers;
}

proc string getWristLocator(string $hand) {
    string $knuckles[];
    $knuckles = `listRelatives -f $hand`;
    for ($i=0; $i<size($knuckles); $i++) {
        // check that the name contains finger
        if (stringContains($knuckles[$i], "wrist", 0)) {
            return $knuckles[$i];
        }
    }
    error "No wrist found...";
    return "ERROR";
}

proc string getRidgeLocator(string $hand) {
    string $knuckles[];
    $knuckles = `listRelatives -f $hand`;
    for ($i=0; $i<size($knuckles); $i++) {
        // check that the name contains finger
        if (stringContains($knuckles[$i], "ridge", 0)) {
            return $knuckles[$i];
        }
    }
    error "No ridge found...";
    return "ERROR";
}

proc float[] calculateMiddleFinger(string $wrist, string $ridge, string $midFinger, int $numOfKnuckles) {
    float $knuckleLoc[], $ridgeLoc[], $wristLoc[], $tipLoc[], $jointLocs[], $deltaJoint[], $step;
    string $relatives[], $tipLocator;
    
    $wristLoc = `xform -q -ws -rp $wrist`;
    $ridgeLoc = `xform -q -ws -rp $ridge`;
    $knuckleLoc = `xform -q -ws -rp $midFinger`;
    
    $jointLocs[0] = $wristLoc[0];
    $jointLocs[1] = $wristLoc[1];
    $jointLocs[2] = $wristLoc[2];
    $jointLocs[3] = $ridgeLoc[0];
    $jointLocs[4] = $ridgeLoc[1];
    $jointLocs[5] = $ridgeLoc[2];
    $jointLocs[6] = $knuckleLoc[0];
    $jointLocs[7] = $knuckleLoc[1];
    $jointLocs[8] = $knuckleLoc[2];
    
    $relatives = `listRelatives -f $midFinger`;
    for ($i=0; $i<size($relatives); $i++) {
        // check that the name contains tip
        if (stringContains($relatives[$i], "tip", 0)) {
            $tipLocator = $relatives[$i];
        }
    }
    $tipLoc = `xform -q -ws -rp $tipLocator`;
    $deltaJoint = vecSub($tipLoc, $knuckleLoc);
    
    for ($i=1; $i<=$numOfKnuckles; $i++) {
        $step = linstep(0, $numOfKnuckles, $i);
        $jointLocs[size($jointLocs)] = $knuckleLoc[0] + ($step * $deltaJoint[0]);
        $jointLocs[size($jointLocs)] = $knuckleLoc[1] + ($step * $deltaJoint[1]);
        $jointLocs[size($jointLocs)] = $knuckleLoc[2] + ($step * $deltaJoint[2]);
    }
    return $jointLocs;
}

proc string[] createMiddleFingerJointNames(int $numOfKnuckles) {
    string $jointNames[];
    $jointNames = {"wrist", "ridge", "middleFinger"};
    for ($i=3; $i<=$numOfKnuckles+1; $i++) {
        $jointNames[$i] = "knuckle";
    }
    $jointNames[size($jointNames)] = "tip";
    return $jointNames;
}

proc float[] calculateRidge(string $root, string $ridgeRoot, string $midFinger, string $hand, int $left) {
    // vector v root to ridge, u perpendicular to v, n root to knuckle, nP projection of N on U
    float $v[], $u[], $n[], $nP[], $rootLoc[], $ridgeRootLoc[], $knuckleLoc[];
    
    int $i, $passedMid, $numLeftRidge;
    string $knuckles[], $leftRidgeKnuckles[], $rightRidgeKnuckles[];
    float $knuckleLoc[], $deltaLoc[], $jointLocs[], $vecs[], $dotProd;
    
    $rootLoc = `xform -q -ws -rp $midFinger`;
    $ridgeRootLoc = `xform -q -ws -rp $ridgeRoot`;
    
    // calculate v and u
    $v = vecSub($ridgeRootLoc, $rootLoc);
    // calculate $u and normalise it
    $u = crossProduct($v, {0.0,1,0}, 1, 1);
    
    // find knuckle locators for the left or right ridge
    $knuckles = `listRelatives -f $hand`;
    $passedMid = 0;
    // add the middle finger to the start of the right ridge
    $rightRidgeKnuckles[0] = $midFinger;
    for ($i=0; $i<size($knuckles); $i++) {
        if (strcmp($knuckles[$i], $midFinger) == 0) {
            $passedMid = 1;
        } else if (stringContains($knuckles[$i], "finger", 0)) {
            if ($passedMid) {
                $rightRidgeKnuckles[size($rightRidgeKnuckles)] = $knuckles[$i];
            } else {
                $leftRidgeKnuckles[size($leftRidgeKnuckles)] = $knuckles[$i];
            }
        }
    }    
    // add the middle finger to the end of the left ridge
    $leftRidgeKnuckles[size($leftRidgeKnuckles)] = $midFinger;
    
    // calculate each vector between the locators
    if ($left) {
        // left ridge
        $numLeftRidge = size($leftRidgeKnuckles);
        for ($i=0; $i<$numLeftRidge-1; $i++) {
            // get kncukle position
            $knuckleLoc = `xform -q -ws -rp $leftRidgeKnuckles[$i]`;
            // calculate $n vector from ridge root to knuckle
            $n = vecSub($knuckleLoc, $ridgeRootLoc);
            // project the vector onto $u to calculate nPrime
            $dotProd = dotProduct($n, $u, 0);
            $nP = vecMultFloat($u, $dotProd);
            // we put in ($numLeftRidge-1)*3 - $i*3 in the vecs index to reverse the order of the left ridge
            $vecs[($numLeftRidge-2)*3 - $i*3] = $nP[0];
            $vecs[($numLeftRidge-2)*3 - $i*3 + 1] = $nP[1];
            $vecs[($numLeftRidge-2)*3 - $i*3 + 2] = $nP[2];
        }
    } else {
        // right ridge
        for ($i=0; $i<size($rightRidgeKnuckles)-1; $i++) {
            // get knuckle position
            $knuckleLoc = `xform -q -ws -rp $rightRidgeKnuckles[$i+1]`;
            // calculate $n vector from ridge root to knuckle
            $n = vecSub($knuckleLoc, $ridgeRootLoc);
            // project the vector onto $u to calculate nPrime
            $dotProd = dotProduct($n, $u, 0);
            $nP = vecMultFloat($u, $dotProd);    
            // we put in ($numLeftRidge-1)*3 - $i*3 in the vecs index to reverse the order of the left ridge
            $vecs[$i*3]  = $nP[0];
            $vecs[$i*3 +1]  = $nP[1];
            $vecs[$i*3 +2]  = $nP[2];
        }
    }
    
    // add extra joint to the ridge
    $jointLocs[0] = $vecs[0] * .50 + $ridgeRootLoc[0];
    $jointLocs[1] = $vecs[1] * .50 + $ridgeRootLoc[1];
    $jointLocs[2] = $vecs[2] * .50 + $ridgeRootLoc[2];
    for ($i=0; $i<size($vecs)/3; $i++) {
        $jointLocs[$i*3+3] = $vecs[$i*3] + $ridgeRootLoc[0];
        $jointLocs[$i*3+4] = $vecs[$i*3+1] + $ridgeRootLoc[1];
        $jointLocs[$i*3+5] = $vecs[$i*3+2] + $ridgeRootLoc[2];
    }
    return $jointLocs;
}

// returns either the left or right fingers of a hand... left or right being the left or right side of the middle finger
proc string[] getRidgeFingers(string $midFinger, string $hand, int $left) {
    int $i, $passedMid;
    string $knuckles[], $leftRidgeKnuckles[], $rightRidgeKnuckles[];
    
    $knuckles = `listRelatives -f $hand`;
    $passedMid = 0;

    for ($i=0; $i<size($knuckles); $i++) {
        if (strcmp($knuckles[$i], $midFinger) == 0) {
            $passedMid = 1;
        } else if (stringContains($knuckles[$i], "finger", 0)) {
            if ($passedMid) {
                $rightRidgeKnuckles[size($rightRidgeKnuckles)] = $knuckles[$i];
            } else {
                $leftRidgeKnuckles[size($leftRidgeKnuckles)] = $knuckles[$i];
            }
        }
    }
    if ($left) {
        return $leftRidgeKnuckles;
    } else {
        return $rightRidgeKnuckles;
    }
}

proc string[] createRidgeJointNames(int $num) {
    string $jointNames[];
    for ($i=0; $i<$num; $i++) {
        $jointNames[$i] = "ridge";
    }
    return $jointNames;
}

proc string[] buildFKFinger(string $root, string $ridgeFinger, float $upVector[], int $numOfKnuckles) {
    string $relatives[], $tipLocator, $jointNames[], $newFinger[];
    float $knuckleLoc[], $tipLoc[], $jointLocs[], $deltaJoint[], $step;

    // Get the knuckle and the tip locator positions
    $knuckleLoc = `xform -q -ws -rp $ridgeFinger`;    
    $relatives = `listRelatives -f $ridgeFinger`;
    for ($i=0; $i<size($relatives); $i++) {
        // check that the name contains tip
        if (stringContains($relatives[$i], "tip", 0)) {
            $tipLocator = $relatives[$i];
        }
    }
    $tipLoc = `xform -q -ws -rp $tipLocator`;
    $deltaJoint = vecSub($tipLoc, $knuckleLoc);
    
    for ($i=0; $i<=$numOfKnuckles; $i++) {
        $step = linstep(0, $numOfKnuckles, $i);
        $jointLocs[$i*3] = $knuckleLoc[0] + ($step * $deltaJoint[0]);
        $jointLocs[$i*3+1] = $knuckleLoc[1] + ($step * $deltaJoint[1]);
        $jointLocs[$i*3+2] = $knuckleLoc[2] + ($step * $deltaJoint[2]);
        $jointNames[$i] = "knuckle";
    }
    $jointNames[0] = "finger";
    $jointNames[size($jointNames)-1] = "tip";
    $newFinger = modRigBuildJoints($root, $jointLocs, $upVector, $jointNames, "FK_");
    return $newFinger;
}

// adds curl controls to the $root node, $axis is x=1 y=2 z=3
proc createCurl(string $root, string $attrName, string $newFinger[], int $axis, int $startIndex, int $endIndex) {
    int $i;
    string $buffer[], $newAttrName;
    tokenize $attrName "|" $buffer;
    $newAttrName = "Curl" + $buffer[size($buffer)-1];
    addAttr -ln $newAttrName -at double -dv 0 $root;
    setAttr -e -keyable true ($root + "." + $newAttrName);
    for ($i=$startIndex; $i<=$endIndex; $i++) {
        connectAttr -f ($root + "." + $newAttrName) ($newFinger[$i] + ".rz");
    }
}

// adds the cupping controls to the $root node
proc createCupping(string $root, string $ridgeLeft[], string $ridgeRight[]) {
    int $i;
    addAttr -ln "cupping" -at double -dv 0 $root;
    setAttr -e -keyable true ($root + ".cupping");
    for ($i=0; $i<size($ridgeLeft)-1; $i++) {
        connectAttr -f ($root + ".cupping") ($ridgeLeft[$i] + ".rz");
    }
    for ($i=0; $i<size($ridgeRight)-1; $i++) {
        connectAttr -f ($root + ".cupping") ($ridgeRight[$i] + ".rz");
    }
}

proc string[] buildFKThumb(string $root, string $hand, int $numOfKnuckles) {
    string $relatives[], $rel, $thumb, $tipLocator, $jointNames[], $upVectorLoc, $newThumb[];
    float $rootLoc[], $knuckleLoc[], $tipLoc[], $deltaJoint[], $upVectorLocPos[], $upVector[];
    
    // get the root loc
    $rootLoc = `xform -q -ws -rp $root`;
    
    // find the thumb
    $relatives = `listRelatives -f $hand`;
    for ($rel in $relatives) {
        if (stringContains($rel, "thumb", 0)) {
            $thumb = $rel;
        }
    }
    if (size($thumb) > 0) {
        $knuckleLoc = `xform -q -ws -rp $thumb`;
    
        // create an intermediate joint 25% between root and knuckle
        $jointLocs[0] = ($knuckleLoc[0] - $rootLoc[0])*.25 + $rootLoc[0];
        $jointLocs[1] = ($knuckleLoc[1] - $rootLoc[1])*.25 + $rootLoc[1];
        $jointLocs[2] = ($knuckleLoc[2] - $rootLoc[2])*.25 + $rootLoc[2];
        $jointNames[0] = "palm";
    
        // Get the knuckle and the tip locator positions
        $relatives = `listRelatives -f $thumb`;
        for ($rel in $relatives) {
            // check that the name contains tip
            if (stringContains($rel, "tip", 0)) {
                $tipLocator = $rel;
            } else if (stringContains($rel, "upvector", 0)) {
                $upVectorLoc = $rel;
            }
        }
        $tipLoc = `xform -q -ws -rp $tipLocator`;
    
        // get the upvector locators position
        $upVectorLocPos = `xform -q -ws -rp $upVectorLoc`;
        // calculate the up vector
        $upVector = vecSub($upVectorLocPos, $knuckleLoc);
        // calculate the vector between the joints
        $deltaJoint = vecSub($tipLoc, $knuckleLoc);
    
        for ($i=1; $i<=$numOfKnuckles; $i++) {
            $step = linstep(0, $numOfKnuckles-1, $i-1);
            $jointLocs[size($jointLocs)] = $knuckleLoc[0] + ($step * $deltaJoint[0]);
            $jointLocs[size($jointLocs)] = $knuckleLoc[1] + ($step * $deltaJoint[1]);
            $jointLocs[size($jointLocs)] = $knuckleLoc[2] + ($step * $deltaJoint[2]);
            $jointNames[$i] = "knuckle";
        }
        $newThumb = modRigBuildJoints($root, $jointLocs, $upVector, $jointNames, "FK_");
        return $newThumb;
    } else {
        return {};
    }
}

proc float[] getFingerUpVector(string $hand) {
    int $flag;
    string $relatives[], $rel, $firstFinger, $upVectorLocator;
    float $knuckleLoc[], $upVectorLocPos[], $upVector[];
    
    $relatives = `listRelatives -f $hand`;
    for ($rel in $relatives) {
        // check that the name contains finger
        if (stringContains($rel, "finger", 0) && $flag != 1) {
            $firstFinger = $rel;
            $flag = 1;
        }
    }
    $flag = 0;
    $relatives = `listRelatives -f $firstFinger`;
    for ($rel in $relatives) {
        // check that the name contains finger
        if (stringContains($rel, "upvector", 0) && $flag != 1) {
            $upVectorLocator = $rel;
            $flag = 1;
        }
    }
    
    if ($flag) {
        $knuckleLoc = `xform -q -ws -rp $firstFinger`;
        $upVectorLocPos = `xform -q -ws -rp $upVectorLocator `;
        $upVector = vecSub($upVectorLocPos, $knuckleLoc);
    } else {
        $upVector = {0,1,0};
    }
    normalize($upVector);
    return $upVector;
}

global proc modRigBuildHand(string $roots[], string $hands[]) {
    // Declare some variables...
    string $midFingerFK[], $midFingerFK2[], $midFingerIK[], $midFingerIK2[], $midFingerBind[];
    string $ridgeLeftFK[], $ridgeLeftFK2[], $ridgeLeftIK[], $ridgeLeftIK2[], $ridgeLeftBind[];
    string $ridgeRightFK[], $ridgeRightFK2[], $ridgeRightIK[], $ridgeRightIK2[], $ridgeRightBind[];
    string $fullSkelFK[], $fullSkelFK2[], $fullSkelIK[], $fullSkelIK2[], $fullSkelBind[], $fullSkelBind2[];
    string $prefix, $jointNames[], $midFinger, $wrist, $ridge, $ridgeFingers[], $newFinger[], $newThumb[];
    string $fkRoot, $ikRoot, $bindRoot;
    
    string $remFKAttrs[] = {"tx","ty","tz","sx","sy","sz"};
    string $remAllAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};
    
    float $upVector[], $jointLocs[], $initialFKIKBlend, $upVectorLoc[], $upVectorLocRef[];
    
    int $i, $j, $createSkels[], $templateSkels[], $hideSkels[], $numOfKnuckles, $numOfFingers;
    
    //Initialise variables from the GUI
    $numOfKnuckles = `intFieldGrp -q -v1 handNumOfKnuckles`;
    $createSkels[0] = `checkBoxGrp -q -v1 handFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 handFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 handFkIkCheckBox`;
    $initialFKIKBlend = `radioButtonGrp -q -sl handFkIkInitialBlend` == 1 ? 0 : 10;
    
    // prefix contains the group name with a pipe for easy naming of locators etc...
    $prefix = $hands[0] + "|";
    
    // If there is no joint selected, create root joint at first shoulder locator
    if (size($roots) < 1) {
        select -cl;
        warning "No root node selected. Creating a root joint at world 0...\n";
        $fkRoot = $ikRoot = $bindRoot = `joint -p 0 0 0 -n "aRoot"`;
    } else if (size($roots) == 1) {
        $fkRoot = $ikRoot = $bindRoot = $roots[0];
    } else if (size($roots) == 2) {
        if ($createSkels[0]) {
            $fkRoot = $roots[0];
            if ($createSkels[1]) {
                $ikRoot = $roots[1];
            } else {
                $bindRoot = $roots[1];
            }
        } else {
            $ikRoot = $roots[0];
            $bindRoot = $roots[1];
        }
    } else if (size($roots) == 3) {
        $fkRoot = $roots[0];
        $ikRoot = $roots[1];
        $bindRoot = $roots[2];
    }
    
    // Build required skeleton and options for each hand
    for ($i=0; $i<size($hands); $i++) {
        print ("Creating hand " + $hands[$i] + "...\n");
        // prefix helps in the naming of each locator...
        $prefix = $hands[$i] + "|";
        $midFinger = getMidFinger($hands[$i]);
        $numOfFingers = getNumberOfFingers($hands[$i]);
        $wrist = getWristLocator($hands[$i]);
        $ridge = getRidgeLocator($hands[$i]);
        $upVector = getFingerUpVector($hands[$i]);
        if ($createSkels[0]) {
            // Create the middle finger
            $jointLocs = calculateMiddleFinger($wrist, $ridge, $midFinger, $numOfKnuckles);
            $jointNames = createMiddleFingerJointNames($numOfKnuckles);
            $midFingerFK = modRigBuildJoints($fkRoot, $jointLocs, $upVector, $jointNames, "FK_");
            if (size($midFingerFK) != $numOfKnuckles+3) { error ("Number of expected joints on midFingerFK does not equal " + ($numOfKnuckles+3) + ".\n"); }
            
            // NEED TO CREATE A VARIABLE WHICH HAS EVERY* JOINT OF THE HAND IN IT TO USE FOR THE FK IK BLENDING
            $fullSkelFK = $midFingerFK;
            
            // Create the left Ridge
            $jointLocs = calculateRidge($fkRoot, $midFingerFK[1], $midFinger, $hands[$i], 1);
            $jointNames = createRidgeJointNames(size($jointLocs)/3);
            $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 1);
            $ridgeLeftFK = modRigBuildJoints($midFingerFK[1], $jointLocs, $upVector, $jointNames, "FK_");
            if (size($ridgeLeftFK) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeLeftFK does not equal " + (size($ridgeFingers)+1) + ".\n"); }
            // add to full hand skeleton array
            appendStringArray($fullSkelFK, $ridgeLeftFK, size($ridgeLeftFK));
            for ($j=0; $j<size($ridgeFingers); $j++) {
                $newFinger = buildFKFinger($ridgeLeftFK[size($ridgeLeftFK)-2-$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                appendStringArray($fullSkelFK, $newFinger, size($newFinger));
                createCurl($midFingerFK[0], $newFinger[0], $newFinger, 3, 0, 2);
            }
            
            // create the middle curl here to keep the attributes in order
            createCurl($midFingerFK[0], "middle", $midFingerFK, 3, 2, 4);
            
            // Create the right Ridge
            $jointLocs = calculateRidge($fkRoot, $midFingerFK[1], $midFinger, $hands[$i], 0);
            $jointNames = createRidgeJointNames(size($jointLocs)/3);
            $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 0);
            $ridgeRightFK = modRigBuildJoints($midFingerFK[1], $jointLocs, $upVector, $jointNames, "FK_");
            if (size($ridgeRightFK) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeRightFK does not equal " + (size($ridgeFingers)+1) + ".\n"); }
            // add to full hand skeleton array
            appendStringArray($fullSkelFK, $ridgeRightFK, size($ridgeRightFK));
            for ($j=0; $j<size($ridgeFingers); $j++) {
                $newFinger = buildFKFinger($ridgeRightFK[$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                appendStringArray($fullSkelFK, $newFinger, size($newFinger));
                createCurl($midFingerFK[0], $newFinger[0], $newFinger, 3, 0, 2);
            }
            $newThumb = buildFKThumb($midFingerFK[0], $hands[$i], $numOfKnuckles);
            if (size($newThumb) > 0) { createCurl($midFingerFK[0], "thumb", $newThumb, 3, 1, 2); }
            appendStringArray($fullSkelFK, $newThumb, size($newThumb));
            
            createCupping($midFingerFK[0], $ridgeLeftFK, $ridgeRightFK);
            
            // lock and remove FK attributes
            removeChannels($fullSkelFK, $remFKAttrs, 1);
            
            // add selection handles for just the wrist
            toggleSelectionHandle($fullSkelFK[0]);
                
            // colour code
            colourObjectWithColour($fullSkelFK[0], 1);
                
                
            // If FK is selected but not IK and size of roots is 3 then we create 2 FK skeletons...
            if ($createSkels[1] == 0 && size($roots) == 3) {
            	// Create the middle finger
                // ************************************************************************COULD BE OPTIMISED BY NOT RECALCULATING A LOT OF THIS... trade off more conditionals
                $jointLocs = calculateMiddleFinger($wrist, $ridge, $midFinger, $numOfKnuckles);
                $jointNames = createMiddleFingerJointNames($numOfKnuckles);
                $midFingerFK2 = modRigBuildJoints($ikRoot, $jointLocs, $upVector, $jointNames, "FK_");
                if (size($midFingerFK2) != $numOfKnuckles+3) { error ("Number of expected joints on midFingerFK2 does not equal " + ($numOfKnuckles+3) + ".\n"); }
            
           	// NEED TO CREATE A VARIABLE WHICH HAS EVERY* JOINT OF THE HAND IN IT TO USE FOR THE FK IK BLENDING
                $fullSkelFK2 = $midFingerFK2;
                
                // Create the left Ridge
                $jointLocs = calculateRidge($ikRoot, $midFingerFK[1], $midFinger, $hands[$i], 1);
                $jointNames = createRidgeJointNames(size($jointLocs)/3);
                $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 1);
                $ridgeLeftFK2 = modRigBuildJoints($midFingerFK2[1], $jointLocs, $upVector, $jointNames, "FK_");
                if (size($ridgeLeftFK2) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeLeftFK2 does not equal " + (size($ridgeFingers)+1) + ".\n"); }
                // add to full hand skeleton array
                appendStringArray($fullSkelFK2, $ridgeLeftFK2, size($ridgeLeftFK2));
                for ($j=0; $j<size($ridgeFingers); $j++) {
                    $newFinger = buildFKFinger($ridgeLeftFK2[size($ridgeLeftFK2)-2-$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                    appendStringArray($fullSkelFK2, $newFinger, size($newFinger));
                    createCurl($midFingerFK2[0], $newFinger[0], $newFinger, 3, 0, 2);
                }
                
                // create the middle curl here to keep the attributes in order
                createCurl($midFingerFK2[0], "middle", $midFingerFK2, 3, 2, 4);
            
                // Create the right Ridge
                $jointLocs = calculateRidge($ikRoot, $midFingerFK[1], $midFinger, $hands[$i], 0);
                $jointNames = createRidgeJointNames(size($jointLocs)/3);
                $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 0);
                $ridgeRightFK2 = modRigBuildJoints($midFingerFK2[1], $jointLocs, $upVector, $jointNames, "FK_");
                if (size($ridgeRightFK2) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeRightFK2 does not equal " + (size($ridgeFingers)+1) + ".\n"); }
                // add to full hand skeleton array
                appendStringArray($fullSkelFK2, $ridgeRightFK2, size($ridgeRightFK2));
                for ($j=0; $j<size($ridgeFingers); $j++) {
                    $newFinger = buildFKFinger($ridgeRightFK2[$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                    appendStringArray($fullSkelFK2, $newFinger, size($newFinger));
                    createCurl($midFingerFK2[0], $newFinger[0], $newFinger, 3, 0, 2);
                }
                $newThumb = buildFKThumb($midFingerFK2[0], $hands[$i], $numOfKnuckles);
                if (size($newThumb) > 0) { createCurl($midFingerFK2[0], "thumb", $newThumb, 3, 1, 2); }
                appendStringArray($fullSkelFK2, $newThumb, size($newThumb));
            
                createCupping($midFingerFK2[0], $ridgeLeftFK2, $ridgeRightFK2);
                
                // lock and remove FK attributes
                removeChannels($fullSkelFK2, $remFKAttrs, 1);
                
                // add selection handles for just the wrist
                toggleSelectionHandle($fullSkelFK2[0]);
                
                // colour code
                colourObjectWithColour($fullSkelFK2[0], 2);
            }
        }
        
        if ($createSkels[1]) {
        
        }
        
        if ($createSkels[2]) {
            // Create the middle finger
            // ************************************************************************COULD BE OPTIMISED BY NOT RECALCULATING A LOT OF THIS... trade off more conditionals
            $jointLocs = calculateMiddleFinger($wrist, $ridge, $midFinger, $numOfKnuckles);
            $jointNames = createMiddleFingerJointNames($numOfKnuckles);
            $midFingerBind = modRigBuildJoints($bindRoot, $jointLocs, $upVector, $jointNames, "BIND_");
            if (size($midFingerBind) != $numOfKnuckles+3) { error ("Number of expected joints on midFingerBind does not equal " + ($numOfKnuckles+3) + ".\n"); }
            
            // NEED TO CREATE A VARIABLE WHICH HAS EVERY* JOINT OF THE HAND IN IT TO USE FOR THE FK IK BLENDING
            $fullSkelBind = $midFingerBind;
        
            // Create the left Ridge
            $jointLocs = calculateRidge($bindRoot, $midFingerBind[1], $midFinger, $hands[$i], 1);
            $jointNames = createRidgeJointNames(size($jointLocs)/3);
            $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 1);
            $ridgeLeftBind = modRigBuildJoints($midFingerBind[1], $jointLocs, $upVector, $jointNames, "BIND_");
            if (size($ridgeLeftBind) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeLeftBind does not equal " + (size($ridgeFingers)+1) + ".\n"); }
            // add to full hand skeleton array
            appendStringArray($fullSkelBind, $ridgeLeftBind, size($ridgeLeftBind));
            for ($j=0; $j<size($ridgeFingers); $j++) {
                $newFinger = buildFKFinger($ridgeLeftBind[size($ridgeLeftBind)-2-$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                appendStringArray($fullSkelBind, $newFinger, size($newFinger));
            }
            // Create the right Ridge
            $jointLocs = calculateRidge($bindRoot, $midFingerBind[1], $midFinger, $hands[$i], 0);
            $jointNames = createRidgeJointNames(size($jointLocs)/3);
            $ridgeFingers = getRidgeFingers($midFinger, $hands[$i], 0);
            $ridgeRightBind = modRigBuildJoints($midFingerBind[1], $jointLocs, $upVector, $jointNames, "BIND_");
            if (size($ridgeRightBind) != (size($ridgeFingers)+1)) { error ("Number of expected joints on ridgeRightBind does not equal " + (size($ridgeFingers)+1) + ".\n"); }
            // add to full hand skeleton array
            appendStringArray($fullSkelBind, $ridgeRightBind, size($ridgeRightBind));
            for ($j=0; $j<size($ridgeFingers); $j++) {
                $newFinger = buildFKFinger($ridgeRightBind[$j], $ridgeFingers[$j], $upVector, $numOfKnuckles);
                appendStringArray($fullSkelBind, $newFinger, size($newFinger));
            }
            $newThumb = buildFKThumb($midFingerBind[0], $hands[$i], $numOfKnuckles);
            appendStringArray($fullSkelBind, $newThumb, size($newThumb));
            
            // remove all channel attributes from the bind skel
            removeChannels($fullSkelBind, $remAllAttrs, 0);
            // add selection handle to blend joint
            toggleSelectionHandle($fullSkelBind[0]);
            // colour code
            colourObjectWithColour($fullSkelBind[0], 3);
        }
        // Create orient contraints between FK, IK and Bind skeletons
        // Create blending of weights or direct connections
        if ($createSkels[0] && $createSkels[1] && $createSkels[2]) {
            //buildIKFKBlend($skelIK, $skelFK, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) == 3) {
            buildAxisBlend($fullSkelFK2, $fullSkelFK, $fullSkelBind, $initialFKIKBlend, 0);
            //buildIKFKBlend($fullSkelFK2, $fullSkelFK, $fullSkelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($fullSkelFK, $fullSkelBind);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) == 3) {
            //buildIKFKBlend($skelIK, $skelIK2, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) < 3) {
            //buildDirectConnections($skelIK, $skelBind);
        }
        // delete the locators
        delete $hands[$i];
    
        // Rename the root joints of each skeleton created to help the animator identify the joints...        
        // Only rename if they have only 1 root selected... they should already know whats FK, IK and Bind if they have more than one root sel
    
        // Template and hide the required skels
        if ($createSkels[0] && $templateSkels[0]) { toggle -state on -te $fullSkelFK[0]; }
        if ($createSkels[1] && $templateSkels[1]) { toggle -state on -te $fullSkelIK[0]; }
        if ($createSkels[2] && $templateSkels[2]) { toggle -state on -te $fullSkelBind[0]; }
        if ($createSkels[0] && $hideSkels[0]) { hide $fullSkelFK[0]; }
        if ($createSkels[1] && $hideSkels[1]) { hide $fullSkelIK[0]; }
        if ($createSkels[2] && $hideSkels[2]) { hide $fullSkelBind[0]; }        
    }
    select -cl;
}

// VERY FIRST FINGER FUNCTION - NOT REALLY IN USE NOW
global proc modRigCalculateFinger() {
    // Variable declarations...
    string $root, $selected[], $type[], $object, $locator, $relatives[], $relative, $jointNames[], $temp[];
    int $numOfKnuckles, $smoothstep;
    float $locT[], $rootT[], $joints[], $ss, $dist[];;
    
    // Variable initialisation
    $temp = getSelected(0);
    $root = $temp[0];
    $locator = $temp[1];
    $numOfKnuckles = `intFieldGrp -q -v1 fingerNumOfKnuckles`;
    // if dist is exponential smoothstep == 1 else == 2
    $smoothstep = (`radioButtonGrp -q -sl fingerDistType` == 1);
    
    // if we have no root node selected then create one
    if (strcmp($root, "") == 0) {
    	$root = `joint -p 0 0 0 -n "finger#"`;
    }
    $rootT = `xform -q -ws -rp $root`;

    // if we have a locator, then set the length to locator - length else set length to 2
    if (strcmp($locator, "") != 0) {
        $locT = `getAttr ($locator + ".t")`;
    } else {
        $locT = {$rootT[0]+2,$rootT[1],$rootT[2]};
    }
    
    // Determine the distance between the locator and the root joint
    $dist[0] = $locT[0] - $rootT[0];
    $dist[1] = $locT[1] - $rootT[1];
    $dist[2] = $locT[2] - $rootT[2];
    
    // For each knuckle, interpolate the distance and add the joints to the array
    for ($i=0; $i<=$numOfKnuckles; $i++) {
        if ($smoothstep) {
            $ss = smoothstep(1-($numOfKnuckles+1),$numOfKnuckles+1,$i+1);
        } else {
            $ss = linstep(0,$numOfKnuckles+1,$i+1);
        }
        $joints[$i*3] = $ss * $dist[0] + $rootT[0];
        $joints[$i*3 + 1] = $ss * $dist[1] + $rootT[1];
        $joints[$i*3 + 2] = $ss * $dist[2] + $rootT[2];
        $jointNames[$i] = ("Knuckle_" + $i);
    }
    
    // build the finger
    modRigBuildJoints($root, $joints, {0,1,0}, $jointNames, "");
}


//######################################################################################
//# SPINE
//######################################################################################
global proc string modRigLayoutSpine() {
    string $group;
    int $numOfSpines, $numOfMajVert, $i;
    float $cvLocs[];
    
    $numOfSpines = `intFieldGrp -q -v1 spineNumOfSpines`;
    $numOfCVs = 4; // actually just refering to how many cvs on a curve we have
    
    print ("Laying out " + $numOfSpines + " spine(s)...\n");
    
    // determine interpolated vertebrae
    $cvLocs[0] = 0;
    $cvLocs[1] = 9.5;
    $cvLocs[2] = 0;
    for ($i=1; $i<$numOfCVs; $i++) {
        $cvLocs[$i*3] = 0;
        $cvLocs[$i*3+1] = 9.5 + (6.5/($numOfCVs-1))*$i;
        $cvLocs[$i*3+2] = 0;
    }
    
    // for each spine create a group of locators to indicate joints
    for ($i=1; $i<=$numOfSpines; $i++) {
        $group = createCurveGroup("Spine", "spineCurve", $cvLocs);
        // Create a locator for the up vector of a joint...
        createLoc("spineUpVector", ($group + "|spineCurve"), {0.0,9.5,1}, 0.4);
    }
    
    select -r $group;
    return $group;
}

global proc string[] modRigPreBuildSpine(string $roots[], string $locs[]) {
    string $locs[], $roots[], $object, $missing[], $spines[], $bindSkel[];
    int $i, $numOfSkelsToCreate;
    
    // Check that if only FK, IK or only Bind is checked then ensure that only 1 root is selected...
    // if more than one is checked then ensure that at least 1 and no more than 3 roots are selected...
    $numOfSkelsToCreate = `checkBoxGrp -q -v1 spineFkIkCheckBox` + `checkBoxGrp -q -v2 spineFkIkCheckBox` + `checkBoxGrp -q -v3 spineFkIkCheckBox`;
    
    if (size($roots) > 3) { error "Too many root joints selected. The maximum is 3."; }
    
    if ($numOfSkelsToCreate == 0) {
        error "No Skeletons to create...";
    } else if ($numOfSkelsToCreate == 1 && size($roots) > 1) {
        error "Too many root joints selected";
    } else if ($numOfSkelsToCreate == 3 && size($roots) == 2) {
        error "To create Cube, IK and Bind skeletons you must have 0, 1 or 3 roots selected, not 2.";
    }

    // Check that all locators are present to create a spine
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    // check that all the locators required for a spine are present (will work for curves as well as locators)
    for ($i=0; $i<size($locs); $i++) {
        print ("Checking validity of " + $locs[$i] + "...\n");
        $missing = checkLoc({$locs[$i]+"|spineCurve", $locs[$i]+"|spineCurve|spineUpVector"});
        if (size($missing) > 0) {
            reportMissing($missing,$locs[$i],0);
        } else {
            $spines[size($spines)] = $locs[$i];
        }
    }
    
    // create the spines if they are valid
    if (size($spines)) {
        $bindSkel = modRigBuildSpine($roots, $spines);
    }
    return $bindSkel;
}

// Calculates the joint locs along the spine curve... $numJoints is major and minor joints but not including the 'extra' joint
proc float[] getJointLocs(string $spine, int $numJoints) {
    int $i;
    float $jointLocs[], $jointLoc[];
    string $locators[], $locator, $mPath;
    string $curve = ($spine + "|spineCurve");
    
    // We have to use a motion path because pointOnCurve and arcLength only work in parametric units
    
    // create a locator
    $locators = `spaceLocator`;
    $locator = $locators[0];
    
    // attatch the locator with a motion path to the curve
    $mPath = `pathAnimation -c $curve -stu 1 -etu 1 -fm 1 $locator`;
    // move the u and sample the world space of the locator to get the jointLoc
    setAttr ($mPath + ".uValue") 0;
    $jointLoc = `xform -q -ws -rp $locator`;
    // Add the $jointLoc to the $jointLocs array
    for ($i=0; $i<3; $i++) { $jointLocs[size($jointLocs)] = $jointLoc[$i]; }
    
    // Calculate the 'extra' joint
    setAttr ($mPath + ".uValue") ((1.0/(float)($numJoints-1))/2.0);
    $jointLoc = `xform -q -ws -rp $locator`;
    for ($i=0; $i<3; $i++) { $jointLocs[size($jointLocs)] = $jointLoc[$i]; }
    
    // Calculate all the other joints
    for ($i=1; $i<$numJoints; $i++) {
        setAttr ($mPath + ".uValue") ((1.0/(float)($numJoints-1))*$i);
        $jointLoc = `xform -q -ws -rp $locator`;
        for ($j=0; $j<3; $j++) { $jointLocs[size($jointLocs)] = $jointLoc[$j]; }
    }
    // clean up
    delete $locator $mPath;
    
    return $jointLocs;
}

// creates the joint names... $numJoints is major and minor joints but not including the 'extra' joint
proc string[] getJointNames(int $numOfMajVert, int $numOfMinVert) {
    int $i;
    string $names[];
    $names = {"spineBase", "extraJoint"};
    for ($j=0; $j<$numOfMinVert; $j++) {
        $names[size($names)] = "minVert";
    }
    for ($i=1; $i<$numOfMajVert-1; $i++) {
        $names[size($names)] = "majVert";
        for ($j=0; $j<$numOfMinVert; $j++) {
            $names[size($names)] = "minVert";
        }
    }
    $names[size($names)] = "topVert";
    return $names;
}


proc string createClusterHandle(string $curve, int $cv, string $name, float $selOffset[]) {
    string $cluster[];
    string $remAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};
    
    // add clusters to the curve
    $cluster = `cluster -n ($name + "Cluster") -rel -en 1 ($curve + ".cv["+$cv+"]")`;
    
    // add a selection handle to the cluster handle
    toggleSelectionHandleWithOffset($cluster[1], $selOffset);
    
    // colour cluster
    colourObjectWithColour($cluster[1], 2);
    
    return $cluster[1];
}

proc string createSplineIK(string $root, string $startJoint, string $endEffector, string $curve, string $name) {
    string $ikHandleObjects[], $clusters[], $group;
    float $loc[];
    
    $clusters[0] = createClusterHandle($curve, 1, "base", {0.0,0,-2});
    $clusters[1] = createClusterHandle($curve, 2, "mid", {0.0,0,-2});
    $clusters[2] = createClusterHandle($curve, 3, "top", {0.0,0,-2});
    
    // group the clusters
    $group = `group -n "Clusters" $clusters[0] $clusters[1] $clusters[2]`;
    // move the pivot point of the cluster group to the pivot point of the root and parent it
    $loc = `xform -q -ws -rp $root`;
    xform -ws -rp $loc[0] $loc[1] $loc[2] $group;
    parent $group $root;
    
    // create an ikSpline
    $ikHandleObjects = `ikHandle -n $name -sj $startJoint -ee $endEffector -c $curve -sol "ikSplineSolver" -ccv 0 -pcv 1 -roc 0`;
    
    // add the twist attribute to the base cluster and connect it to the IK handle
    addAttr -ln twist -at double $clusters[0];
    setAttr -e -keyable true ($clusters[0] + ".twist");
    connectAttr ($clusters[0] + ".twist") ($ikHandleObjects[0] + ".twist");
    
    // return the ikHandle
    return ("|" + $ikHandleObjects[0]);
}

proc string createCubeSetup(string $nonRootCubeJoints[], int $numOfMinVert) {
    string $temp[], $cube, $cubes[], $group, $groups[], $cubeGroup, $cmd, $cubeJoints[];
    int $i, $currMinVert, $lastMajVert;
    
    string $remCubeGeoAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};
    string $remCubeGroupAttrs[] = {"tx","ty","tz","sx","sy","sz"};
    
    // some references need to be reference from the world root
    $cubeJoints = addRootReference($nonRootCubeJoints);
    
    $cubeGroup = ("|" + `group -n "Cubes" -em`);
    
    // create the cube at world 0
    $temp = `polyCube -w 1 -h 1 -d 1 -sx 1 -sy 1 -sz 1 -ax 0 1 0 -tx 1 -ch 0`;
    // we store all the created cubes in the cubes array
    // we use index 1 here purely to help in the loops later where we ignore the extra joint
    // basically because the loop index starts at 2 and we need to reference the root joint cube we just set it to one
    // so that the inital loop will be 2 - 1 to get to the first cube (so we can skip the extra joint which sits at index 1 of cubeJoints)
    $cubes[1] = $temp[0];
    // disable all cube rendering attributes (except double sided)
    setAndLockAttrs($cubes[1], {"castsShadows", "receiveShadows", "motionBlur", "primaryVisibility", "smoothShading", "visibleInReflections", "visibleInRefractions"}, 0);
    // orient the cube to the same axis as the joint
    $temp = `orientConstraint $cubeJoints[0] $cubes[1]`;
    delete $temp[0];
    // group the cube to help with animation
    $group = `group -n "cube#" $cubes[1]`;
    $groups[1] = $group;
    // colour code the group
    colourObjectWithColour($groups[1], 1);
    //point constrain the group to the joint
    pointConstraint $cubeJoints[0] ("|" + $group);
    //orient constrain the point to the cube
    orientConstraint -n "orCon" $cubes[1] $cubeJoints[0];
    // add selection handle to major cube
    toggleSelectionHandle($groups[1]);
    //parent the new cube group to the total cube group
    parent ("|" + $group) $cubeGroup;
    
    // do the same as above for the rest of the joints skipping the 'extra joint'
    for ($i=2; $i<size($cubeJoints); $i++) {
        $temp = `polyCube -w 1 -h 1 -d 1 -sx 1 -sy 1 -sz 1 -ax 0 1 0 -tx 1 -ch 0`;
        $cubes[$i] = $temp[0];
        setAndLockAttrs($cubes[$i], {"castsShadows", "receiveShadows", "motionBlur", "primaryVisibility", "smoothShading", "visibleInReflections", "visibleInRefractions"}, 0);
        $temp = `orientConstraint $cubeJoints[$i] $cubes[$i]`;
        delete $temp[0];
        $group = `group -n "cube#" $cubes[$i]`;
        $groups[$i] = $group;
        // colour code the group
        colourObjectWithColour($groups[$i], 1);
        pointConstraint $cubeJoints[$i] ("|" + $group);
        orientConstraint -n "orCon" $cubes[$i] $cubeJoints[$i];
        parent ("|" + $group) $cubeGroup;
    }
    
    float $alpha;
    $lastMajVert = 1; // index of last major vert in the cubes array... remember we used the index 1 above to help with our loops
    if ($numOfMinVert > 0) {    
        for ($i=2; $i<size($cubeJoints); $i++) {
            // determine if this is a minjoint, if so scale down cube and orient constrain to majcubes either side
            // usr currMinVert to determine how to distribute orient constraint weights
            if ($i % ($numOfMinVert+1) != 1) {
                // Minor Vert
                $currMinVert++;
                setAttr ($cubes[$i] + ".sx") 0.5;
                setAttr ($cubes[$i] + ".sy") 0.5;
                setAttr ($cubes[$i] + ".sz") 0.5;
                orientConstraint ($cubeGroup + "|" + $groups[$lastMajVert]) ($cubeGroup + "|" + $groups[$lastMajVert+$numOfMinVert+1]) ($cubeGroup + "|" + $groups[$i]);
                
                // Distribute the weights of the orient constraints according to which minor vert it is.
                // The closer Major cube will have a higher influence on the orient than the further Major cube
                $alpha = 1.0/($numOfMinVert+1);                
                setAttr ($groups[$i] + "_orientConstraint1." + $groups[$lastMajVert] + "W0") (($numOfMinVert+1 - $currMinVert)*$alpha);
                setAttr ($groups[$i] + "_orientConstraint1." + $groups[$lastMajVert+$numOfMinVert+1] + "W1") ($currMinVert*$alpha);
                
            } else {
                // it must be a Major Vert
                // set some variables for loop logic
                $currMinVert = 0;
                $lastMajVert = $i;
                // add selection handle to major cube
                toggleSelectionHandle($groups[$i]);
            }
        }
    }
    // lock and remove FK attributes
    // we need to remove the empty entry at the start of the array before we can call removeChannels
    removeChannels(vecIndexString($cubes, 1, size($cubes)-1), $remCubeGeoAttrs, 1);
    removeChannels(vecIndexString($groups, 1, size($groups)-1) , $remCubeGroupAttrs, 1);
    
    return $cubeGroup;
}

global proc string[] modRigBuildSpine(string $roots[], string $spines[]) {
    // Declare some variables
    string $skelFK[], $skelFK2[], $skelIK[], $skelIK2[], $skelBind[], $jointNames[];
    string $prefix, $cubeGroup, $ikHandle, $temp[];
    string $fkRoot, $ikRoot, $bindRoot;
    
    float $upVector[], $upVectors[], $initialFKIKBlend, $upVectorLoc[], $upVectorLocRef[], $startJoint[], $endJoint[], $deltaJoint[], $jointLocs[];
    
    int $i, $j, $numOfSpines, $numOfMinVert, $numOfMajVert, $createSkels[], $templateSkels[], $hideSkels[], $totalVert;
    
    string $remAllAttrs[] = {"tx","ty","tz","rx","ry","rz","sx","sy","sz"};
    
    //Initialise variables from the GUI
    $numOfMajVert = `intFieldGrp -q -v1 spineNumOfMajVert`;
    $numOfMinVert = `intFieldGrp -q -v1 spineNumOfMinVert`;
    $createSkels[0] = `checkBoxGrp -q -v1 spineFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 spineFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 spineFkIkCheckBox`;
    $initialFKIKBlend = `radioButtonGrp -q -sl spineFkIkInitialBlend` == 1 ? 0 : 10;
    
    // prefix contains the group name with a pipe for easy naming of locators etc...
    $prefix = $spines[0] + "|";
    
    // If there is no joint selected, create root joint at first shoulder locator
    if (size($roots) < 1) {
        select -cl;
        warning "No root node selected. Creating a root joint at 0, 9.5, 0...\n";
        $fkRoot = $ikRoot = $bindRoot = ("|" + `joint -p 0 9.5 0 -n "spineRoot#"`);
    } else if (size($roots) == 1) {
        $fkRoot = $ikRoot = $bindRoot = $roots[0];
    } else if (size($roots) == 2) {
        if ($createSkels[0]) {
            $fkRoot = $roots[0];
            if ($createSkels[1]) {
                $ikRoot = $roots[1];
            } else {
                $bindRoot = $roots[1];
            }
        } else {
            $ikRoot = $roots[0];
            $bindRoot = $roots[1];
        }
    } else if (size($roots) == 3) {
        $fkRoot = $roots[0];
        $ikRoot = $roots[1];
        $bindRoot = $roots[2];
    }
    
    // Build required skeleton and options for each spine
    for ($i=0; $i<size($spines); $i++) {
        print ("Creating spine " + $spines[$i] + "...\n");
        // prefix helps in the naming of each locator...
        $prefix = $spines[$i] + "|";
        // Up vector loc grabs the world pos of the upvector locator
        $upVectorLoc = `xform -q -ws -rp ($prefix + "spineCurve|spineUpVector")`;
        // Up vector loc ref grabs the world pos of the locator to base the upvector loc from
        $upVectorLocRef = `xform -q -ws -rp ($prefix + "spineCurve")`;
        $upVector = vecSub($upVectorLoc, $upVectorLocRef);
        normalize($upVector);
        // delete the upVector
        delete ($prefix + "spineCurve|spineUpVector");
        
        $jointLocs = getJointLocs($spines[$i], $numOfMajVert + (($numOfMajVert-1)*$numOfMinVert));
        $jointNames = getJointNames($numOfMajVert, $numOfMinVert);
        $totalVert = size($jointNames);
        if ($createSkels[0]) {
            // Create the FK skelton...
            $skelFK = modRigBuildJoints($fkRoot, $jointLocs, $upVector, $jointNames, "FK_");
            if (size($skelFK) != $totalVert) { error ("Number of expected joints on skelFK does not equal " + $totalVert + ".\n"); }
            $cubeGroup = createCubeSetup($skelFK, $numOfMinVert);
            parent $cubeGroup $fkRoot;
            // lock and remove FK attributes
            removeChannels($skelFK, $remAllAttrs, 1);
            // colour code
            colourObjectWithColour($skelFK[0], 1);
            // If FK is selected but not IK and size of roots is 3 then we create 2 FK skeletons...
            if ($createSkels[1] == 0 && size($roots) == 3) {
                $skelFK2 =  modRigBuildJoints($ikRoot, $jointLocs, $upVector, $jointNames, "FK_");
                if (size($skelFK2) != $totalVert) { error ("Number of expected joints on skelFK2 does not equal " + $totalVert + ".\n"); }
                $cubeGroup = createCubeSetup($skelFK2, $numOfMinVert);
                parent $cubeGroup $ikRoot;
                // lock and remove FK attributes
                removeChannels($skelFK, $remAllAttrs, 1);
                // colour code
                colourObjectWithColour($skelFK2[0], 1);
            }
        }
        
        if ($createSkels[1]) {
            // Create the IK skelton...
            $skelIK =  modRigBuildJoints($ikRoot, $jointLocs, $upVector, $jointNames, "IK_");
            if (size($skelIK) != $totalVert) { error ("Number of expected joints on skelIK does not equal " + $totalVert + ".\n"); }
            // Create IK spline
            $ikHandle = createSplineIK($ikRoot, $skelIK[0], $skelIK[size($skelIK)-1], ($prefix + "spineCurve"), "splineIK");
            parent $ikHandle $ikRoot;
            // remove IK attributes
            removeChannels($skelIK, $remAllAttrs, 0);
            // colour code
            colourObjectWithColour($skelIK[0], 2);   
            // if IK is selected but not FK and size of roots is 3 then we create 2 IK skels
            if ($createSkels[0] == 0 && size($roots) == 3) {
                $skelIK2 =  modRigBuildJoints($fkRoot, $jointLocs, $upVector, $jointNames, "IK_");
                if (size($skelIK2) != $totalVert) { error ("Number of expected joints on skelIK2 does not equal " + $totalVert + ".\n"); }
                // Create IK spine
                $ikHandle = createSplineIK($fkRoot, $skelIK2[0], $skelIK2[size($skelIK2)-1], ($prefix + "spineCurve"), "splineIK2");
                parent $ikHandle $fkRoot;
                // remove IK attributes
                removeChannels($skelIK2, $remAllAttrs, 0);
                // colour code
                colourObjectWithColour($skelIK2[0], 2);
            }
        }
        
        if ($createSkels[2]) {
            // Create the Bind skeleton...
            $skelBind =  modRigBuildJoints($bindRoot, $jointLocs, $upVector, $jointNames, "BIND_");
            if (size($skelBind) != $totalVert) { error ("Number of expected joints on skelBind does not equal " + $totalVert + ".\n"); }
            // remove all channel attributes from the bind skel
            removeChannels($skelBind, $remAllAttrs, 0);
            toggleSelectionHandleWithOffset($skelBind[0], {0,-2,0});
            // colour code
            colourObjectWithColour($skelBind[0], 3);
        }
        // Create orient contraints between FK, IK and Bind skeletons
        // Create blending of weights or direct connections
        if ($createSkels[0] && $createSkels[1] && $createSkels[2]) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelIK, $skelFK, $skelBind, $initialFKIKBlend, 0);
            //buildAxisBlend($skelIK, $skelFK, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) == 3) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelFK, $skelFK2, $skelBind, $initialFKIKBlend, 0);
            //buildAxisBlend($skelFK, $skelFK2, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[0] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelFK, $skelBind);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) == 3) {
            // Orient constraint the Bind skeleton to the FK and IK skeletons and create blend control
            buildIKFKBlend($skelIK, $skelIK2, $skelBind, $initialFKIKBlend, 0);
            //buildAxisBlend($skelIK, $skelIK2, $skelBind, $initialFKIKBlend, 0);
        } else if ($createSkels[1] && $createSkels[2] && size($roots) < 3) {
            buildDirectConnections($skelIK, $skelBind);
        }
        
        // delete the locators
        delete $spines[$i];
    
        // Template and hide the required skels
        if ($createSkels[0] && $templateSkels[0]) { toggle -state on -te $skelFK[0]; }
        if ($createSkels[1] && $templateSkels[1]) { toggle -state on -te $skelIK[0]; }
        if ($createSkels[2] && $templateSkels[2]) { toggle -state on -te $skelBind[0]; }
        if ($createSkels[0] && $hideSkels[0]) { hide $skelFK[0]; }
        if ($createSkels[1] && $hideSkels[1]) { hide $skelIK[0]; }
        if ($createSkels[2] && $hideSkels[2]) { hide $skelBind[0]; }
    }
    select -cl;
    return $skelBind;
}


//######################################################################################
//# FULL SKELETON - BIPED
//######################################################################################
// need to layout all the limbs using there respective layout functions
global proc modRigLayoutBiped(int $mirror) {
    string $group = `group -em -n "Biped#"`;
    string $spine, $rightArm, $leftArm, $rightHand, $leftHand, $rightLeg, $leftLeg;
    
    $spine = modRigLayoutSpine();
    parent $spine $group;
    $leftArm = modRigLayoutArmSkeleton(1);
    $leftHand = modRigLayoutHand(1);
    $leftLeg = modRigLayoutReverseFootSkeleton(1);
    if ($mirror) {
        $rightLeg = modRigLayoutReverseFootSkeleton(0);
    	$rightArm = modRigLayoutArmSkeleton(0);
    	$rightHand = modRigLayoutHand(0);
        parent $rightArm $group;
        parent $rightHand $group;
        parent $rightLeg $group;
    }
    parent $leftArm $group;
    parent $leftHand $group;
    parent $leftLeg $group;
    
    select -r $group;
}

// simply mirrors the arm, hand and leg locators
global proc modRigMirrorBiped() {
    string $missing[], $locs[];
    int $sx, $sy, $sz;
    $sx = (`radioButtonGrp -q -sl mirrorBipedAxisCheckBox` == 1) ? -1:1;
    $sy = (`radioButtonGrp -q -sl mirrorBipedAxisCheckBox` == 2) ? -1:1;
    $sz = (`radioButtonGrp -q -sl mirrorBipedAxisCheckBox` == 3) ? -1:1;
    // Check for spine, two arms, two hands, and two legs
    $locs = getSelected(1);
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    for ($i=0; $i<size($locs); $i++) {
        $rels = `listRelatives $locs`;
        if (size($rels) != 4) {
            warning "Size of Biped group should be 4 when mirroring... there may be errors.";
        }
        // check all the locators are there
        $missing = checkLoc({$locs[$i]+"|Spine", $locs[$i]+"|Arm", $locs[$i]+"|Hand", $locs[$i]+"|Leg"});
        if (size($missing) > 0) {
            reportMissing($missing, $locs[$i], 0);
        } else {
            // duplicate the groups
            duplicate ($locs[$i]+"|Arm") ($locs[$i]+"|Hand") ($locs[$i]+"|Leg");
            // currently the hand groups pivot point is at the wrist not at world 0 so we must move it to world 0 to mirror
            move -a 0 0 0 ($locs[$i]+ "|Hand1.scalePivot") ($locs[$i]+ "|Hand1.rotatePivot");
            // mirror the locators
            scale $sx $sy $sz ($locs[$i]+"|Arm1") ($locs[$i]+"|Hand1") ($locs[$i]+"|Leg1");
        }
    }    
}

proc createBipedCOGSetup(string $driver, string $cog, string $anim, string $expr) {
    string $animBuffer[], $exprBuffer[];
    // add the extra attribute to our driver node
    addAttr -ln blend_anim_expr -at double  -min 0 -max 10 -dv 0 $driver;
    setAttr -e -keyable true ($driver + ".blend_anim_expr");
    
    // add the orient constraint
    $constraints = `orientConstraint -w 1 -n "orCon" $anim $expr $cog`;
    // As our locators are full paths we need to get just the dag node name in short form to use for the aim constraints.
    $numAnimTokens = `tokenize $anim "|" $animBuffer`;
    $numExprTokens = `tokenize $expr "|" $exprBuffer`;
    // *********THIS IS NAUGHTY... I should be querying the orient constraint to obtain the weights... not just assume it is W0 and W1
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 0 -v 1 ($constraints[0] + "." + $animBuffer[$numAnimTokens-1] + "W0");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 0 -v 0 ($constraints[0] + "." + $exprBuffer[$numExprTokens-1] + "W1");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 10 -v 0 ($constraints[0] + "." + $animBuffer[$numAnimTokens-1] + "W0");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 10 -v 1 ($constraints[0] + "." + $exprBuffer[$numExprTokens-1] + "W1");
    
    
    // add the point constraint
    $constraints = `pointConstraint -w 1 -n "pointCon" $anim $expr $cog`;
    // *********THIS IS NAUGHTY... I should be querying the orient constraint to obtain the weights... not just assume it is W0 and W1
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 0 -v 1 ($constraints[0] + "." + $animBuffer[$numAnimTokens-1] + "W0");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 0 -v 0 ($constraints[0] + "." + $exprBuffer[$numExprTokens-1] + "W1");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 10 -v 0 ($constraints[0] + "." + $animBuffer[$numAnimTokens-1] + "W0");
    setDrivenKeyframe -cd ($driver + ".blend_anim_expr") -dv 10 -v 1 ($constraints[0] + "." + $exprBuffer[$numExprTokens-1] + "W1");
    
}


global proc modRigPreBuildBiped() {
    string $missing[], $locs[], $roots[], $bipeds[], $skel[], $arm[], $buffer[], $temp[], $group, $biped, $prefix, $foot, $foot1;
    float $loc[];
    int $numTokens;
    
    // get the locator and root selections
    $locs = getSelected(1);
    $roots = getSelected(0);
    
    if (size($locs) < 1) {
        error "No Locator Groups selected";
    }
    for ($i=0; $i<size($locs); $i++) {
        // Check for spine, two arms, two hands, and two legs
        $missing = checkLoc({$locs[$i]+"|Spine", $locs[$i]+"|Arm", $locs[$i]+"|Arm1", $locs[$i]+"|Hand", $locs[$i]+"|Hand1", $locs[$i]+"|Leg", $locs[$i]+"|Leg1"});
        if (size($missing) > 0) {
            reportMissing($missing, $locs[$i], 0);           
        } else {
            $biped = `group -em -n "BIPED#"`;
            
            $skel = modRigPreBuildSpine($roots, {$locs[$i] + "|Spine"});
            $foot = modRigPreBuildReverseFootSkeleton({$skel[0]}, {$locs[$i] + "|Leg"}, 1);
            $foot1 = modRigPreBuildReverseFootSkeleton({$skel[0]}, {$locs[$i] + "|Leg1"}, 0);
            $arm = modRigPreBuildArmSkeleton({$skel[size($skel)-1]}, {$locs[$i] + "|Arm"}, 1, $biped);
            modRigPreBuildHand({$arm[size($arm)-1]}, {$locs[$i] + "|Hand"});
            $arm = modRigPreBuildArmSkeleton({$skel[size($skel)-1]}, {$locs[$i] + "|Arm1"}, 0, $biped);
            modRigPreBuildHand({$arm[size($arm)-1]}, {$locs[$i] + "|Hand1"});
            
            // add extra top group nodes
            // first tokenize $skel[0] on |
            $numTokens = `tokenize $skel[0] "|" $buffer`;
            // group and move pivot to the spine base
            $group = `group -n "Offset#" $buffer[0]`;
            $prefix = $group;
            $loc = `xform -q -ws -rp $buffer[0]`;
            xform -ws -rp $loc[0] $loc[1] $loc[2] $group;
            // group and move pivot to the spine base
            $cog = `group -n "COG#" $group`;
            $prefix = $cog + "|" + $prefix;
            xform -ws -rp $loc[0] $loc[1] $loc[2] $cog;
            // group and move pivot to 0, 0, 0
            parent $cog $biped;
            $prefix = "|" + $biped + "|" + $prefix;
            xform -ws -rp 0 0 0 $biped;
            
            // create the two locators to blend between expression centre of gravity and animation
            string $newLoc[] = `spaceLocator -n "Animation#"`;
            string $animLoc = $newLoc[0];
            move -a $loc[0] $loc[1] $loc[2] $animLoc;
            makeIdentity -apply true -t 1 -r 1 -s 1 $animLoc;
            $newLoc = `spaceLocator -n "Expression#"`;
            string $expLoc = $newLoc[0];
            move -a $loc[0] $loc[1] $loc[2] $expLoc;
            makeIdentity -apply true -t 1 -r 1 -s 1 $expLoc;
            $temp = `parent $animLoc $biped`;
            $animLoc = $temp[0];
            // colour code the anim locator
            colourObjectWithColour($animLoc, 1);
            toggleSelectionHandleWithOffset($animLoc, {0,-2,0});
            $temp = `parent $expLoc $biped`;
            $expLoc = $temp[0];
            hide $expLoc;
            
            // parent feet to biped
            parent $foot $foot1 $biped;
            
            // add the expression to control the 
            expression -s ($expLoc+".translateX = ("+$foot+".translateX + "+$foot1+".translateX)/2;\r"+$expLoc+".translateZ = ("+$foot+".translateZ + "+$foot1+".translateZ)/2;\r"+$expLoc+".rotateY = ("+$foot+".rotateY + "+$foot1+".rotateY)/2;\r\r")  -o "" -ae 1 -uc all ;
            
            // add the point and orient constraints
            createBipedCOGSetup($prefix + $skel[0], $cog, $animLoc, $expLoc);
            
            // delete the locators
            delete $locs[$i];
            
            select $biped;
        }
    }
}

//######################################################################################
//# GUI
//######################################################################################
global proc toggleSpineGUI() {
    int $createSkels[], $templateSkels[], $hideSkels[];
    
    //Initialise variables from the GUI
    $createSkels[0] = `checkBoxGrp -q -v1 spineFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 spineFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 spineFkIkCheckBox`;
    //legFkIkInitialBlend
    radioButtonGrp -e -en ($createSkels[0] && $createSkels[1] && $createSkels[2]) spineFkIkInitialBlend;
}

global proc toggleLegGUI() {
    int $createSkels[], $templateSkels[], $hideSkels[];
    
    //Initialise variables from the GUI
    $createSkels[0] = `checkBoxGrp -q -v1 legFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 legFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 legFkIkCheckBox`;
    //legFkIkInitialBlend
    radioButtonGrp -e -en ($createSkels[0] && $createSkels[1] && $createSkels[2]) legFkIkInitialBlend;
}

global proc toggleArmGUI() {
    int $createSkels[], $templateSkels[], $hideSkels[];
    
    //Initialise variables from the GUI
    $createSkels[0] = `checkBoxGrp -q -v1 armFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 armFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 armFkIkCheckBox`;
    //legFkIkInitialBlend

    radioButtonGrp -e -en ($createSkels[0] && $createSkels[1] && $createSkels[2]) armFkIkInitialBlend;
}

global proc toggleHandGUI() {
    int $createSkels[], $templateSkels[], $hideSkels[];
    
    //Initialise variables from the GUI
    $createSkels[0] = `checkBoxGrp -q -v1 handFkIkCheckBox`;
    $createSkels[1] = `checkBoxGrp -q -v2 handFkIkCheckBox`;
    $createSkels[2] = `checkBoxGrp -q -v3 handFkIkCheckBox`;
    //legFkIkInitialBlend
    radioButtonGrp -e -en ($createSkels[0] && $createSkels[1] && $createSkels[2]) handFkIkInitialBlend;
}

global proc buildModularRigWindow(string $modularRigWindow)
{
    string $winPrefix = "//aa_server3/work/maya_scripts/icons/";
    string $nixPrefix = "/usr/work/maya_scripts/icons/";
    string $iconPrefix;
    
	window
		-menuBar true
		-menuBarVisible true
		-title "ModularRig v0.1"
		-iconName "ModularRig"
		-titleBar true
		-minimizeButton true -maximizeButton true
		-h 735 -w 375
		-sizeable true $modularRigWindow;
	menu
		-label "Help"
		-tearOff false;
	menuItem
    		-label "Help on modularRig."
    		-c "doModularRigHelp()";

    string $form = `formLayout -numberOfDivisions 100`;
    string $scroll = `scrollLayout -verticalScrollBarThickness 16 -horizontalScrollBarThickness 0`;
    columnLayout -rs 5  -adjustableColumn true;
    rowLayout -numberOfColumns 2
              -columnWidth2 50 350
              -ct2 "left" "left"
              -co2 5 15;
    //text at top
    if ( `about -nt`) {
      image -w 50 -h 20 -image "//aa_server3/work/maya_scripts/gmd_logo.gif";
      $iconPrefix = $winPrefix;
    } else {
      image -w 50 -h 20 -image "/usr/work/maya_scripts/gmd_logo.gif";
      $iconPrefix = $nixPrefix;
    }
    text -label "(C)DP 2003. Programmed by Stuart Bryson" -align "left";
    setParent ..;
    
    //################################################ BIPED ################################################
    //symbolButton -image ($iconPrefix + "DPRightHandLayout.xpm") -c "modRigLayoutBiped(0)";
    //symbolButton -image ($iconPrefix + "DPRightHandLayout.xpm") -c "modRigLayoutBiped(1)";
    //symbolButton -image ($iconPrefix + "DPRightHandBuild.xpm") -c "modRigPreBuildBiped()";
    frameLayout -label "Biped" -cl 0 -labelAlign "center" -borderStyle "etchedIn" -cll true;
        columnLayout -rs 5 -adjustableColumn true;
            rowLayout -numberOfColumns 3 -columnWidth3 34 34 282;
                symbolButton -image ($iconPrefix + "DPBipedHalfLayout.xpm") -c "modRigLayoutBiped(0)";
                symbolButton -image ($iconPrefix + "DPBipedLayoutMirror.xpm") -c "modRigMirrorBiped()";
                radioButtonGrp -nrb 3 -label "Mirror Axis:" -l1 "X" -l2 "Y" -l3 "Z" -sl 1 -cw4 120 50 50 62 mirrorBipedAxisCheckBox;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                symbolButton -image ($iconPrefix + "DPBipedLayout.xpm") -c "modRigLayoutBiped(1)";
                symbolButton -image ($iconPrefix + "DPBipedBuild.xpm") -c "modRigPreBuildBiped()";
                text -label "";
                text -label "";
            setParent ..;
        setParent ..;
    setParent ..;
    
    //################################################ HANDS ################################################
    frameLayout -label "Hands" -cl 1 -labelAlign "center" -borderStyle "etchedIn" -cll true;
        columnLayout -rs 5 -adjustableColumn true;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                symbolButton -image ($iconPrefix + "DPRightHandLayout.xpm") -c "modRigLayoutHand(0)";
                symbolButton -image ($iconPrefix + "DPLeftHandLayout.xpm") -c "modRigLayoutHand(1)";
                intFieldGrp -nf 1 -v1 1 -label "# Hands:" -cw2 80 63 handNumOfHands;
                intFieldGrp -nf 1 -v1 4 -label "# Fingers:" -cw2 80 63 handNumOfFingers;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                text -label "";
                checkBoxGrp -ncb 1 -label "" -l1 "Thumb" -v1 1 -cw2 10 133 handThumbCheckBox;
                text -label "";
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPRightHandBuild.xpm") -c "modRigPreBuildHand(getSelected(0), getSelected(1))";
                intFieldGrp -nf 1 -v1 3 -label "# Knuckles:" -cw2 80 63 handNumOfKnuckles;
                radioButtonGrp -label "" -nrb 2 -labelArray2 "Exp." "Even" -sl 2 -cw3 3 50 90 handDistType;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 82 200;
                text -label "";
                text -label "";
                checkBoxGrp -ncb 3 -label "Create:" -l1 "FK" -l2 "IK" -l3 "Bind" -v1 1 -v2 0 -v3 0 -cw4 80 50 50 102 -cc "toggleHandGUI()" handFkIkCheckBox;
            setParent ..;
            rowLayout -numberOfColumns 3 -columnWidth3 34 34 282;
                text -label "";
                text -label "";
                radioButtonGrp -label "Blend" -nrb 2 -labelArray2 "FK" "IK" -sl 1 -cw3 80 101 101 handFkIkInitialBlend;
            setParent ..;
            separator;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPFinger.xpm") -c "modRigCalculateFinger()";
                radioButtonGrp -label "" -nrb 2 -labelArray2 "Exp." "Even" -sl 2 -cw3 3 50 90 fingerDistType;
                intFieldGrp -nf 1 -v1 3 -label "# Knuckles:" -cw2 80 63 fingerNumOfKnuckles;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPThumb.xpm") -c "";
                radioButtonGrp -label "" -nrb 2 -labelArray2 "Exp." "Even" -sl 2 -cw3 3 50 90 thumbDistType;
                intFieldGrp -nf 1 -v1 3 -label "# Knuckles:" -cw2 80 63 thumbNumOfKnuckles;
            setParent ..;
        setParent ..;
    setParent ..;
    
    //################################################ SPINE ################################################
    frameLayout -label "Spine" -cl 1 -labelAlign "center" -borderStyle "etchedIn" -cll true;
        columnLayout -rs 5 -adjustableColumn true;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPSpineLayout.xpm") -c "modRigLayoutSpine()";
                intFieldGrp -nf 1 -v1 1 -label "# Spines:" -cw2 80 63 spineNumOfSpines;
                text -label "";
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPSpineBuild.xpm") -c "modRigPreBuildSpine(getSelected(0), getSelected(1))";
                intFieldGrp -nf 1 -v1 1 -label "# Min Vert:" -cw2 80 63 spineNumOfMinVert;
                intFieldGrp -nf 1 -v1 4 -label "# Maj Vert:" -cw2 80 63 spineNumOfMajVert;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 82 200;
                text -label "";
                text -label "";
                checkBoxGrp -ncb 3 -label "Create:" -l1 "Cube" -l2 "IK" -l3 "Bind" -v1 1 -v2 1 -v3 1 -cw4 80 50 50 102 -cc "toggleSpineGUI()" spineFkIkCheckBox;
            setParent ..;
            rowLayout -numberOfColumns 3 -columnWidth3 34 34 282;
                text -label "";
                text -label "";
                radioButtonGrp -label "Blend" -nrb 2 -labelArray2 "Cube" "IK" -sl 1 -cw3 80 101 101 spineFkIkInitialBlend;
            setParent ..;
        setParent ..;
    setParent ..;
                
    //################################################ LEGS ################################################
    frameLayout -label "Legs" -cl 1 -labelAlign "center" -borderStyle "etchedIn" -cll true;
        columnLayout -rs 5 -adjustableColumn true;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                symbolButton -image ($iconPrefix + "DPRightLegLayout.xpm") -c "modRigLayoutReverseFootSkeleton(0)";
                symbolButton -image ($iconPrefix + "DPLeftLegLayout.xpm") -c "modRigLayoutReverseFootSkeleton(1)";
                intFieldGrp -nf 1 -v1 1 -label "# Legs:" -cw2 80 61 legNumOfLegs;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPLeftLegBuild.xpm") -c "modRigPreBuildReverseFootSkeleton(getSelected(0), getSelected(1), -1)";
                checkBoxGrp -ncb 3 -label "Create:" -l1 "FK" -l2 "IK" -l3 "Bind" -v1 1 -v2 1 -v3 1 -cw4 80 50 50 102 -cc "toggleLegGUI()" legFkIkCheckBox;
            setParent ..;
            rowLayout -numberOfColumns 3 -columnWidth3 34 34 282;
                text -label "";
                text -label "";
                radioButtonGrp -label "Blend" -nrb 2 -labelArray2 "FK" "IK" -sl 1 -cw3 80 101 101 legFkIkInitialBlend;
            setParent ..;
        setParent ..;
    setParent ..;
                
    //################################################ ARMS ################################################
    frameLayout -label "Arms" -cl 1 -labelAlign "center" -borderStyle "etchedIn" -cll true;
        columnLayout -rs 5 -adjustableColumn true;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                symbolButton -image ($iconPrefix + "DPRightArmLayout.xpm") -c "modRigLayoutArmSkeleton(0)";
                symbolButton -image ($iconPrefix + "DPLeftArmLayout.xpm") -c "modRigLayoutArmSkeleton(1)";
                intFieldGrp -nf 1 -v1 1 -label "# Arms:" -cw2 80 61 armNumOfArms;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 141 141;
                text -label "";
                symbolButton -image ($iconPrefix + "DPLeftArmBuild.xpm") -c "modRigPreBuildArmSkeleton(getSelected(0), getSelected(1), -1)";
                intFieldGrp -nf 1 -v1 1 -label "# Bicep:" -cw2 80 61 armNumOfBiceps;
                intFieldGrp -nf 1 -v1 1 -label "# Forearm:" -cw2 80 61 armNumOfForearms;
            setParent ..;
            rowLayout -numberOfColumns 4 -columnWidth4 34 34 82 200;
                text -label "";
                text -label "";
                checkBoxGrp -ncb 3 -label "Create:" -l1 "FK" -l2 "IK" -l3 "Bind" -v1 1 -v2 1 -v3 1 -cw4 80 50 50 102 -cc "toggleArmGUI()" armFkIkCheckBox;
            setParent ..;
            rowLayout -numberOfColumns 3 -columnWidth3 34 34 282;
                text -label "";
                text -label "";
                radioButtonGrp -label "Blend" -nrb 2 -labelArray2 "FK" "IK" -sl 1 -cw3 80 101 101 armFkIkInitialBlend;
            setParent ..;
        setParent ..;
    setParent ..;
                
		//end gui stuff
			setParent ..;
		setParent ..;
    formLayout -edit
      -attachForm     $scroll "top"    0
      -attachForm     $scroll "left"   0
      -attachForm     $scroll "right"  0
      -attachForm     $scroll "bottom"  0
    $form;
}

// This procedure builds the modularRig window if necessary and then shows it.
global proc modularRig()
{
    // Put the wait cursor on and build the  window if it does not exist.
    waitCursor -state on;
    string $modularRigWindow = "modularRigWindow";
    if (!`window -exists $modularRigWindow`)
        buildModularRigWindow($modularRigWindow);

    // Make sure the window is shown and then turn off the wait cursor.
    showWindow $modularRigWindow;
    waitCursor -state off;
}