Example #1
0
def returnPartNestedMessages(partNull):
    """ 
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    DESCRIPTION:
    Returns a nested dictionary of template objects info connected to a part
    
    ARGUMENTS:
    partNull(obj)
    
    RETURNS:
    nestedDict(dict) - nested dictionary of various null's infos
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """
    objectsDict = attributes.returnMessageAttrs(partNull)
    returnDict = {}
    for key in objectsDict.keys():
        returnDict[key] = attributes.returnMessageAttrs(objectsDict[key])
    return returnDict
Example #2
0
def returnPartNestedMessages(partNull):
    """ 
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    DESCRIPTION:
    Returns a nested dictionary of template objects info connected to a part
    
    ARGUMENTS:
    partNull(obj)
    
    RETURNS:
    nestedDict(dict) - nested dictionary of various null's infos
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """
    objectsDict = attributes.returnMessageAttrs(partNull)
    returnDict = {}
    for key in objectsDict.keys():
        returnDict[key] =  attributes.returnMessageAttrs(objectsDict[key])
    return returnDict
Example #3
0
def returnModules(masterNull):
    """ 
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    DESCRIPTION:
    Returns all the modules connected to a master null
    
    ARGUMENTS:
    masterNull(string)
    
    RETURNS:
    modules(list)
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """
    modulesNull = returnInfoTypeNull(masterNull, 'modules')
    moduleNames = attributes.returnMessageAttrs(modulesNull)
    modules = []
    for module in moduleNames:
        modules.append(attributes.returnMessageObject(modulesNull, module))
    return modules
Example #4
0
def returnModules(masterNull):
    """ 
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    DESCRIPTION:
    Returns all the modules connected to a master null
    
    ARGUMENTS:
    masterNull(string)
    
    RETURNS:
    modules(list)
    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """
    modulesNull = returnInfoTypeNull(masterNull,'modules')
    moduleNames = attributes.returnMessageAttrs(modulesNull)
    modules = []
    for module in moduleNames:
        modules.append(attributes.returnMessageObject(modulesNull,module))
    return modules
Example #5
0
def surfRigger(objectNull,anchor,worldScale,mirror,mode,jointsPerChain,deformChains,ctrlChains):
    """ Get variables"""
    nullBase = names.stripSuffixObj (objectNull)
    templateNull = (nullBase + '_templateNull')
    moverNull = (nullBase + '_mover')
    templateNullMessageData = []
    templateNullMessageData = attributes.returnMessageAttrs (templateNull)
    templateObjects = []
    coreNamesList = []
    spineJointNumber = int(mc.getAttr (objectNull+'.rollJoints'))
    #spineChainList = search.returnChildrenJoints (spineChain)
    spineChainList = []
    spineChainList.append (anchor)
    jointChains = []
    for set in templateNullMessageData:
        templateObjects.append (set[1])
        coreNamesList.append (set[0])
    #>>>>>>>>>>>>>>>>>>>>>Store skin joint data
    """ check for master skin info group """
    if mc.objExists ('master_skinJntList_grp'):
        masterSkinJointList = ('master_skinJntList_grp')
    else:
        masterSkinJointList = mc.group (n= ('master_skinJntList_grp'), w=True, empty=True)
        mc.parent(masterSkinJointList,'rigStuff_grp')
    """ check for segment skin info group """
    if mc.objExists (nullBase+'_skinJntList_grp'):
        skinJointListGrp = (nullBase+'_skinJntList_grp')
    else:
        skinJointListGrp = mc.group (n= (nullBase+'_skinJntList_grp'), w=True, empty=True)
    attributes.storeObjNameToMessage (skinJointListGrp,masterSkinJointList)
    mc.parent (skinJointListGrp,masterSkinJointList)
    #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    """ Rebuild curve - with actual curve in it!"""
    mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
    mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
    mc.rebuildCurve ((templateObjects[11]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5)
    """ Reverse the curve """
    mc.reverseCurve ((templateObjects[3]),ch=False,rpo=True)
    mc.reverseCurve ((templateObjects[7]),ch=False,rpo=True)
    mc.reverseCurve ((templateObjects[11]),ch=False,rpo=True)
    """ loft our surface to figure out joint positions, then delete it"""
    controlSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(ctrlChains-mode),ch=1,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True)
    mc.select (cl=True)
    jointChains = joints.createJointChainsFromLoftSurface (nullBase,controlSurface[0],2,False)
    frontChain = jointChains[0]
    backChain = jointChains[-1]
    """ Chain - orienting, sizing """
    for chain in jointChains:
        joints.orientJointChain (chain, 'xyz', 'zup')
        joints.setGoodJointRadius(chain,.5)
    #IF we have mode 0, gotta make a main ctrl
    if mode == 0:
        midChain = []
        if (len(jointChains)) > 3:
            midChain = jointChains[int(len(jointChains)/2)]
        else:
            midChain = jointChains[1]
            jointChains.remove(midChain)
        if ctrlChains > 2:
            masterCtrlBuffer = mc.duplicate (midChain[0],parentOnly=True)
        else:
            masterCtrlBuffer = midChain[0]
            mc.delete (midChain[1])
        masterCtrl = mc.rename (masterCtrlBuffer,(nullBase+'_master_anim'))
        position.movePointSnap(masterCtrl,moverNull)
        """ temp parenting the master control for mirroring purposes """
        spineHookJoint = distance.returnClosestObject (masterCtrl, spineChainList)
        mc.parent (masterCtrl,spineHookJoint)
    mc.delete (controlSurface[0])
    #>>>>>>>>>>>>Parent time
    """ Get closest joint """
    if mode == 0:
        for chain in jointChains:
            mc.parent (chain[0],masterCtrl)
    else:
        for chain in jointChains:
            tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
            mc.parent (chain[0],tailHookJoint)
    #>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ctrl Joints to Ctrls
    cnt = 0
    for chain in jointChains:
        ctrlSize = (distance.returnAverageDistanceBetweenObjects (chain)/2)
        for jnt in chain[0:-1]:
            rigging.makeObjCtrl (jnt,ctrlSize)
        """ adds our Anim tag """
        chainBuffer = []
        chainBuffer = names.addSuffixList ('anim', chain)
        jointChains[cnt]= chainBuffer
        cnt +=1
    #>>>>>>>>>>>>>>>>>>>Mirroring while getting chain info
    """ If mirroring ...."""
    if mirror == True:
        # if we have a main control
        leftSkinChains = []
        rightSkinChains = []
        masterCtrls = []
        if mode == 0:
            leftChain = []
            rightChain = []
            finHeirarchy = []
            finHeirarchy.append (masterCtrl)
            children = search.returnChildrenJoints (masterCtrl)
            finHeirarchy += children
            leftChain = names.addPrefixList ('left',finHeirarchy)
            masterCtrl = leftChain [0]
            rightChainBuffer = mc.mirrorJoint (masterCtrl,mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right'])
            rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint')
            rightChain = rightChainJointBuffer
            leftSkinChains.append(leftChain)
            rightSkinChains.append(rightChain)
            masterCtrls.append(leftChain[0])
            masterCtrls.append(rightChain[0])
        else:
            for chain in jointChains:
                leftChain =[]
                leftChain = names.addPrefixList ('left',chain)
                rightChainBuffer = (mc.mirrorJoint (leftChain[0],mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right']))
                rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint')
                rightChain = rightChainJointBuffer
                rightSkinChains.append (rightChainJointBuffer)
                leftSkinChains.append (leftChain)
        """ complile our chains to lists of skin joints """
        leftSkinJointList=[]
        rightSkinJointList=[]
        for chain in leftSkinChains:
            for jnt in chain:
                leftSkinJointList.append (jnt)
        for chain in rightSkinChains:
            for jnt in chain:
                rightSkinJointList.append (jnt)
        """if we're not mirroring, let's return our skin joints for the deformation surface"""
    else:
        skinJointList = []
        skinChains = []
        for chain in jointChains:
            skinChains.append (chain)
            for jnt in chain:
                skinJointList.append (jnt)
                
    #>>>>>>>>>>>>>>>>>>>>>>>>>>Time to make the deformation surface stuff
    """ Rebuild curve - with actual curve in it!"""
    #mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5)
    #mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5)
    """ loft our surface to figure out joint positions, then delete it"""
    deformSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(deformChains-1),ch=0,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True)
    if mirror == True:
        deformSurfaceNameBuffer = deformSurface[0]
        """we have a surface to mirror..."""
        surfaceMirrorBuffer = mc.duplicate (deformSurface[0])
        mc.setAttr ((surfaceMirrorBuffer[0]+'.sx'),-1)
        leftBuffer = mc.rename (deformSurface[0],('left_'+deformSurfaceNameBuffer))
        rightBuffer = mc.rename (surfaceMirrorBuffer[0],('right_'+deformSurfaceNameBuffer))
        deformSurface[0]=leftBuffer
        deformSurface.append(rightBuffer)
        leftDeformJointChains = joints.createJointChainsFromLoftSurface (('left_'+nullBase),deformSurface[0],2,False)
        rightDeformJointChains = joints.createJointChainsFromLoftSurface (('right_'+nullBase),deformSurface[1],2,False)
        """ Connecting to surface """
        for chain in leftDeformJointChains:
            attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup')
            tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
            """ break the connection so we can parent it"""
            """first return the original thing to follow"""
            parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
            attributes.doBreakConnection (chain[0]+'.translate')
            #mc.parent (chain[0],tailHookJoint)
            """ reconstrain it to the driver"""
            constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
            mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
            """ store the skin joint data """
            for jnt in chain:
                attributes.storeObjNameToMessage (jnt,skinJointListGrp)

        for chain in rightDeformJointChains:
            attachSurfaceMirrorReturn = joints.attachJointChainToSurface (chain,deformSurface[1],'xyz','zup')
            tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
            """ break the connection s we can parent it"""
            """first return the original thing to follow"""
            parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
            attributes.doBreakConnection (chain[0]+'.translate')
            #mc.parent (chain[0],tailHookJoint)
            """ reconstrain it to the driver"""
            constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
            mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
            """ store the skin joint data """
            for jnt in chain:
                attributes.storeObjNameToMessage (jnt,skinJointListGrp)

        """ parent the scale stuff to rig stuff grp"""
        mc.select (cl=True)
        for item in attachSurfaceReturn[0]:
            mc.parent(item,'rigStuff_grp')
        for item in attachSurfaceMirrorReturn[0]:
            mc.parent(item,'rigStuff_grp')
        """ hook up world scale """
        mc.connectAttr (worldScale,attachSurfaceReturn[1])
        mc.connectAttr (worldScale,attachSurfaceMirrorReturn[1])
        #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Skin in the control joints
        """ Time to set skin our surface to our control joints """
        mc.skinCluster (leftSkinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
        mc.skinCluster (rightSkinJointList,deformSurface[1],tsb=True, n=(deformSurface[1]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
    #>>>>>If we,re not mirrored, let's make our deform setup
    else:
        deformJointChains = []
        deformJointChains = joints.createJointChainsFromLoftSurface (nullBase,deformSurface[0],2,False)
        """ Connecting to surface """
        for chain in deformJointChains:
            attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup')
            tailHookJoint = distance.returnClosestObject (chain[0], spineChainList)
            """ break the connection so we can parent it"""
            """first return the original thing to follow"""
            parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate'))
            attributes.doBreakConnection (chain[0]+'.translate')
            #mc.parent (chain[0],tailHookJoint)
            """ reconstrain it to the driver"""
            constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True)
            mc.rename (constraintBuffer[0],(chain[0]+'_pointConst'))
            """ store the skin joint data """
            for jnt in chain:
                attributes.storeObjNameToMessage (jnt,skinJointListGrp)
        """ hook up world scale  """
        partScaleBuffer = attachSurfaceReturn[1]
        mc.connectAttr (worldScale, partScaleBuffer)
        """ parent the scale stuff to rig stuff grp"""
        mc.select (cl=True)
        for item in attachSurfaceReturn[0]:
            mc.parent(item,'rigStuff_grp')
        """ Time to set skin our surface to our control joints """
        mc.skinCluster (skinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1)
        
        
    """ Setting up the joint starts"""
    if mode == 0:
        if mirror == True:
            for ctrl in masterCtrls:
                rigging.makeObjCtrl (ctrl,(ctrlSize*4))
                masterCtrlGrp = rigging.groupMeObject (ctrl,True)
                """ Get closest joint and connect the Cntrl """
                spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList)
                mc.parent(masterCtrlGrp,spineHookJoint)
        else:
            rigging.makeObjCtrl (masterCtrl,(ctrlSize*4))
            masterCtrlGrp = rigging.groupMeObject (masterCtrl,True)
            """ Get closest joint and connect the Cntrl """
            spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList)
            mc.parent(masterCtrlGrp,spineHookJoint)
    #else we need to connect the individual chains to the spine
    else:
        if mirror == True:
            for chain in leftSkinChains:
                chainCtrlGrp = rigging.groupMeObject (chain[0],True)
                spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
                mc.parent(chainCtrlGrp,spineHookJoint)
            for chain in rightSkinChains:
                chainCtrlGrp = rigging.groupMeObject (chain[0],True)
                spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
                mc.parent(chainCtrlGrp,spineHookJoint)
        else:
            for chain in skinChains:
                chainCtrlGrp = rigging.groupMeObject (chain[0],True)
                spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList)
                mc.parent(chainCtrlGrp,spineHookJoint)
Example #6
0
def rigArm(objectNull):
    """return variables"""
    nullBase = names.stripSuffixObj(objectNull)
    templateNull = (nullBase + '_templateNull')
    templateNullMessageData = []
    templateNullMessageData = attributes.returnMessageAttrs(templateNull)
    templateObjects = []
    coreNamesList = []
    for set in templateNullMessageData:
        templateObjects.append(set[1])
        coreNamesList.append(set[0])
    """ return rid of locators on our template objects so they don't screw up the distance locators"""
    templateObjects.remove(templateObjects[-1])
    coreNamesList.remove(coreNamesList[-1])
    for obj in templateObjects:
        if mc.objExists(obj + '_loc'):
            mc.delete(obj + '_loc')
    """make joint chains"""
    fkJoints = joints.createJointsFromObjPositions(templateObjects, 'fk')
    mc.select(cl=True)
    ikJoints = joints.createJointsFromObjPositions(templateObjects, 'ik')
    """orient joints"""
    joints.orientJointChain(fkJoints, 'xyz', 'yup')
    joints.orientJointChain(ikJoints, 'xyz', 'yup')
    """set rotation order - CHANGE to go for the names later and optional orientation schemes"""
    joints.setRotationOrderOnJoint(fkJoints[0], 'xyz')
    joints.setRotationOrderOnJoint(fkJoints[1], 'xzy')
    joints.setRotationOrderOnJoint(fkJoints[2], 'zyx')

    joints.setRotationOrderOnJoint(ikJoints[0], 'xyz')
    joints.setRotationOrderOnJoint(ikJoints[1], 'xzy')
    joints.setRotationOrderOnJoint(ikJoints[2], 'zyx')
    """ create hand_anim locs """
    hand_animRegBuffer = locators.locMeObject(ikJoints[2])
    hand_animPinnedBuffer = locators.locMeObject(ikJoints[2])

    hand_animReg = mc.rename(hand_animRegBuffer, (coreNamesList[2] + '_anim'))
    hand_animPinned = mc.rename(hand_animPinnedBuffer,
                                (coreNamesList[2] + '_elbow_anim'))
    """ creating measure stuff """
    # Had to move this up here because distanceDimension doesn't let you specify which locator to use. Need to modify script to account for that
    uprArmMeasureLocBuffer = locators.locMeObject(ikJoints[0])
    handMeasureLocBuffer = locators.locMeObject(ikJoints[2])
    elbowMeasureLocBuffer = locators.locMeObject(ikJoints[1])

    uprArmMeasureLoc = mc.rename(uprArmMeasureLocBuffer,
                                 (coreNamesList[0] + '_dist_loc'))
    handMeasureLoc = mc.rename(handMeasureLocBuffer,
                               (coreNamesList[2] + '_dist_loc'))
    elbowMeasureLoc = mc.rename(elbowMeasureLocBuffer,
                                (coreNamesList[1] + '_dist_loc'))

    measureFullLength = [uprArmMeasureLoc, handMeasureLoc]
    fullLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList(
        measureFullLength)

    measureShoulderToElbow = [uprArmMeasureLoc, elbowMeasureLoc]
    uprLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList(
        measureShoulderToElbow)

    measureElbowToHand = [elbowMeasureLoc, handMeasureLoc]
    lwrLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList(
        measureElbowToHand)
    """>>>Set up Rotation Isolation for FK Mode
    """
    """creates our locator parent"""
    UprArmRoot = locators.locMeObject(fkJoints[0])
    """ Create 4 target locators"""
    UprArmTorsoOrientBuffer = mc.duplicate(UprArmRoot)
    UprArmBodyOrientBuffer = mc.duplicate(UprArmRoot)
    UprArmTorsoOrientDriverBuffer = mc.duplicate(UprArmRoot)
    UprArmBodyOrientDriverBuffer = mc.duplicate(UprArmRoot)
    UprArmOrientBuffer = mc.duplicate(UprArmRoot)
    """names our loctators intelligently"""
    uprArmTorsoOrient = mc.rename(UprArmTorsoOrientBuffer[0],
                                  (coreNamesList[0] + '_torso_orient'))
    uprArmBodyOrient = mc.rename(UprArmBodyOrientBuffer[0],
                                 (coreNamesList[0] + '_body_orient'))
    uprArmTorsoOrientDriver = mc.rename(
        UprArmTorsoOrientDriverBuffer[0],
        (coreNamesList[0] + '_torso_orient_driver'))
    uprArmBodyOrientDriver = mc.rename(
        UprArmBodyOrientDriverBuffer[0],
        (coreNamesList[0] + '_body_orient_driver'))
    UprArmOrient = mc.rename(UprArmOrientBuffer[0],
                             (coreNamesList[0] + '_orient_anim'))
    """orients the orient_anim control placeholder"""
    attributes.setRotationOrderObj(UprArmOrient, 'xzy')
    """parents orient control loc to top node"""
    mc.parent(UprArmOrient, UprArmRoot)
    """parents arm to top loc"""
    mc.parent(fkJoints[0], UprArmOrient)
    """parents top loc and torso orient loc to torso diver"""
    mc.parent(UprArmRoot, uprArmTorsoOrientDriver)
    mc.parent(uprArmTorsoOrient, uprArmTorsoOrientDriver)
    mc.parent(uprArmBodyOrient, uprArmBodyOrientDriver)
    """ makes orient constraint for the fk arm"""
    orConstBuffer = mc.orientConstraint([uprArmBodyOrient, uprArmTorsoOrient],
                                        UprArmRoot,
                                        mo=True,
                                        weight=1)
    orConst = mc.rename(orConstBuffer, (fkJoints[0] + '_orConst'))
    """ adds our constraint toggle """
    mc.addAttr(fkJoints[0], ln='orient', at='enum', en='torso:body:')
    mc.setAttr((fkJoints[0] + '.orient'), keyable=True)
    """ return our orient constraint channels """
    orConstAttrs = (mc.listAttr(orConst, userDefined=True))
    """ setups up toggle to change orientation """
    mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[0]),
                         currentDriver=(fkJoints[0] + '.orient'),
                         driverValue=0,
                         value=0)
    mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[1]),
                         currentDriver=(fkJoints[0] + '.orient'),
                         driverValue=0,
                         value=1)
    mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[0]),
                         currentDriver=(fkJoints[0] + '.orient'),
                         driverValue=1,
                         value=1)
    mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[1]),
                         currentDriver=(fkJoints[0] + '.orient'),
                         driverValue=1,
                         value=0)
    """ >>>Sets up fk arm scaling """
    """ adds our length attribute"""
    mc.addAttr(fkJoints[0],
               ln='length',
               at='float',
               minValue=0,
               defaultValue=1)
    mc.setAttr((fkJoints[0] + '.length'), keyable=True)
    mc.addAttr(fkJoints[1],
               ln='length',
               at='float',
               minValue=0,
               defaultValue=1)
    mc.setAttr((fkJoints[1] + '.length'), keyable=True)
    """ connects length to child joint length """
    currentLength = mc.getAttr(fkJoints[1] + '.translateX')
    mc.setDrivenKeyframe((fkJoints[1] + '.translateX'),
                         currentDriver=(fkJoints[0] + '.length'),
                         driverValue=1,
                         value=currentLength,
                         inTangentType='linear',
                         outTangentType='linear')
    mc.setDrivenKeyframe((fkJoints[1] + '.translateX'),
                         currentDriver=(fkJoints[0] + '.length'),
                         driverValue=0,
                         value=0,
                         inTangentType='linear',
                         outTangentType='linear')

    currentLength = mc.getAttr(fkJoints[2] + '.translateX')
    mc.setDrivenKeyframe((fkJoints[2] + '.translateX'),
                         currentDriver=(fkJoints[1] + '.length'),
                         driverValue=1,
                         value=currentLength,
                         inTangentType='linear',
                         outTangentType='linear')
    mc.setDrivenKeyframe((fkJoints[2] + '.translateX'),
                         currentDriver=(fkJoints[1] + '.length'),
                         driverValue=0,
                         value=0,
                         inTangentType='linear',
                         outTangentType='linear')
    """ set sdk curves to infinity """
    mc.setInfinity((fkJoints[1] + '.translateX'), pri='constant', poi='linear')
    mc.setInfinity((fkJoints[2] + '.translateX'), pri='constant', poi='linear')
    """ lockin stuff down on the fk end """
    for jnt in fkJoints:
        attributes.doSetLockHideKeyableAttr(
            jnt, True, False, False, ['ty', 'tz', 'sx', 'sy', 'sz', 'v'])
    attributes.doSetLockHideKeyableAttr(
        UprArmOrient, True, False, False,
        ['tx', 'ty', 'tz', 'sx', 'sy', 'sz', 'v'])
    attributes.doSetLockHideKeyableAttr(fkJoints[1], False, False, False,
                                        ['tx'])
    attributes.doSetLockHideKeyableAttr(fkJoints[2], False, False, False,
                                        ['tx'])
    """ >>>IK arm time!"""
    """make elbow loc and a hand loc"""
    elbowIKLoc = locators.locMeObject(ikJoints[1])
    handIKLoc = locators.locMeObject(ikJoints[2])
    """set preferred rotation channel on elbow"""
    #---------------------->>>> Need to figure out how to generate this!
    mc.setAttr((ikJoints[1] + '.ry'), -30)
    mc.joint(ikJoints[1], edit=True, setPreferredAngles=True)
    mc.setAttr((ikJoints[1] + '.ry'), 0)
    """set up the ik handle"""
    ikHandleName = (nullBase + '_ikHandle')
    mc.ikHandle(name=ikHandleName,
                startJoint=ikJoints[0],
                endEffector=ikJoints[2],
                sol='ikRPsolver',
                snapHandleFlagToggle=True)
    """Polevector constraint"""
    mc.poleVectorConstraint(elbowIKLoc,
                            ikHandleName,
                            name=(nullBase + '.pvConst'),
                            weight=1.0)
    mc.parent(ikHandleName, handIKLoc)
    """ >>> IK Stretch stuff"""
    """connecting measure stuff"""
    mc.parent(handMeasureLoc, handIKLoc)

    uprArmLength = mc.getAttr(ikJoints[1] + '.tx')
    lwrArmLength = mc.getAttr(ikJoints[2] + '.tx')
    fullLength = (uprArmLength + lwrArmLength)
    driver = (fullLengthMeassureObj[0] + 'Shape.distance')
    """sets base sdk key for length"""
    mc.setDrivenKeyframe((ikJoints[1] + '.tx'),
                         currentDriver=driver,
                         driverValue=fullLength,
                         value=uprArmLength,
                         inTangentType='linear',
                         outTangentType='linear')
    mc.setDrivenKeyframe((ikJoints[2] + '.tx'),
                         currentDriver=driver,
                         driverValue=fullLength,
                         value=lwrArmLength,
                         inTangentType='linear',
                         outTangentType='linear')
    """sets stetch sdk key for length"""
    mc.setDrivenKeyframe((ikJoints[1] + '.tx'),
                         currentDriver=driver,
                         driverValue=(fullLength * 2),
                         value=(uprArmLength * 2),
                         inTangentType='linear',
                         outTangentType='linear')
    mc.setDrivenKeyframe((ikJoints[2] + '.tx'),
                         currentDriver=driver,
                         driverValue=(fullLength * 2),
                         value=(lwrArmLength * 2),
                         inTangentType='linear',
                         outTangentType='linear')

    mc.setInfinity((ikJoints[1] + '.tx'), pri='constant', poi='linear')
    mc.setInfinity((ikJoints[2] + '.tx'), pri='constant', poi='linear')
    """ >>> Set up pinning"""
    """ creates blend node """
    """upr"""
    uprBlendNode = mc.createNode('blendTwoAttr',
                                 name='upr_Choice_blendTwoNode',
                                 skipSelect=True)
    uprSDKCurve = mc.listConnections((ikJoints[1] + '.tx'), source=True)
    mc.connectAttr((uprSDKCurve[0] + '.output'), (uprBlendNode + '.input[0]'),
                   force=True)
    mc.connectAttr((uprLengthMeassureObj[0] + 'Shape.distance'),
                   (uprBlendNode + '.input[1]'),
                   force=True)

    mc.connectAttr((uprBlendNode + '.output'), (ikJoints[1] + '.tx'),
                   force=True)
    """lwr"""
    lwrBlendNode = mc.createNode('blendTwoAttr',
                                 name='lwr_Choice_blendTwoNode',
                                 skipSelect=True)
    lwrSDKCurve = mc.listConnections((ikJoints[2] + '.tx'), source=True)
    mc.connectAttr((lwrSDKCurve[0] + '.output'), (lwrBlendNode + '.input[0]'),
                   force=True)
    mc.connectAttr((lwrLengthMeassureObj[0] + 'Shape.distance'),
                   (lwrBlendNode + '.input[1]'),
                   force=True)

    mc.connectAttr((lwrBlendNode + '.output'), (ikJoints[2] + '.tx'),
                   force=True)
    """adds stetch attrs"""
    mc.addAttr(elbowIKLoc, ln='pin', at='float', minValue=0, defaultValue=1)
    mc.setAttr((elbowIKLoc + '.pin'), keyable=True)

    mc.connectAttr((elbowIKLoc + '.pin'),
                   (uprBlendNode + '.attributesBlender'))
    mc.connectAttr((elbowIKLoc + '.pin'),
                   (lwrBlendNode + '.attributesBlender'))
    mc.setAttr((elbowIKLoc + '.pin'), 0)

    mc.parent(elbowMeasureLoc, elbowIKLoc)
    """ >>> FK lower limb control setup """
    """ creates our pinned lower limb fk joint """
    pinnedLwrLimcgmuffer = mc.duplicate(ikJoints[1], renameChildren=True)

    nonJointStuff = search.returnNonJointObjsInHeirarchy(pinnedLwrLimcgmuffer)
    for item in nonJointStuff:
        mc.delete(item)
    """ name the joint we'll be using """
    pinnedLwrLimb = mc.rename(pinnedLwrLimcgmuffer[0],
                              (coreNamesList[1] + '_pinned_fk_anim'))
    mc.parent(pinnedLwrLimb, elbowIKLoc)
    pinnedLwrLimbEndBuffer = mc.listRelatives(pinnedLwrLimb, children=True)
    mc.rename(pinnedLwrLimbEndBuffer[0], (coreNamesList[1] + '_pinned_fk_end'))
    """ make the hand anim loc """
    mc.parent(hand_animPinned, elbowIKLoc)
    ptConstBuffer = mc.pointConstraint([hand_animReg, hand_animPinned],
                                       handIKLoc,
                                       mo=False,
                                       weight=1)
    """ make the attr to drive it """
    mc.addAttr(elbowIKLoc, ln='forearm', at='enum', en='fk:ik:')
    mc.setAttr((elbowIKLoc + '.forearm'), keyable=True)
    mc.setAttr((elbowIKLoc + '.forearm'), 1)
    """ connect it """
    mc.connectAttr((elbowIKLoc + '.forearm'),
                   (ptConstBuffer[0] + '.' + hand_animReg + 'W0'))
    revNodeBuffer = mc.createNode('reverse', name='hand_revNode')

    mc.connectAttr((elbowIKLoc + '.forearm'), (revNodeBuffer + '.inputX'))
    mc.connectAttr((revNodeBuffer + '.outputX'),
                   (ptConstBuffer[0] + '.' + hand_animPinned + 'W1'))