def addLockKneeElbow():
'''
add lock knee/elbow feature
'''
ikCtrls = {'FL':('IK_ARM_FL_CTRL', 'ElbowLock', 'PVC_ARM_FL_CTRL' , 'jIKArmFL', 'jIKClavL02'),
'FR':('IK_ARM_FR_CTRL', 'ElbowLock', 'PVC_ARM_FR_CTRL' , 'jIKArmFR', 'jIKClavR02'),
'BL':('IK_LEG_BL_CTRL', 'KneeLock', 'PVC_LEG_BL_CTRL', 'jIKLegBL', 'jIKHipBL02'),
'BR':('IK_LEG_BR_CTRL', 'KneeLock', 'PVC_LEG_BR_CTRL', 'jIKLegBR', 'jIKHipBR02')}
for side in ikCtrls:
pm.addAttr(ikCtrls[side][0], sn=ikCtrls[side][1], at='bool')
lockAttr = pm.PyNode('%s.%s'%(ikCtrls[side][0], ikCtrls[side][1]))
lockAttr.set(0, keyable=True, lock=False)
pt1 = pm.PyNode(ikCtrls[side][4])
pt2 = pm.PyNode(ikCtrls[side][2])
pt3 = pm.PyNode(ikCtrls[side][0])
pt1pos = pm.xform(pt1, q=True, ws=True, rp=True)
pt2pos = pm.xform(pt2, q=True, ws=True, rp=True)
pt3pos = pm.xform(pt3, q=True, ws=True, rp=True)
dim1 = pm.distanceDimension(startPoint=pt1pos, endPoint=pt2pos)
dim1Parent = dim1.listRelatives(parent=True)[0]
dim1Parent.rename('%s_lockPos_01'%side)
dim2 = pm.distanceDimension(startPoint=pt3pos, endPoint=pt2pos)
dim2Parent = dim2.listRelatives(parent=True)[0]
dim2Parent.rename('%s_lockPos_02'%side)
loc = dim1.endPoint.listConnections()[0]
loc.rename('loc_%s_%s'%(side,ikCtrls[side][1]))
pm.parentConstraint(ikCtrls[side][2], loc, mo=True)
pm.scaleConstraint('CONSTRAIN', loc, mo=True)
pm.parent((dim1, dim2, loc), 'misc')
cond = pm.createNode('condition', name='cond_adjust_%s_%s'%(side,ikCtrls[side][1]))
jnt01 = pm.PyNode('%s02'%ikCtrls[side][3])
jnt02 = pm.PyNode('%s03'%ikCtrls[side][3])
lockAttr >> cond.firstTerm
cond.secondTerm.set(1)
dim1.distance >> cond.colorIfTrueR
dim2.distance >> cond.colorIfTrueG
cond.colorIfFalseR.set( jnt01.tx.get() )
cond.colorIfFalseG.set( jnt02.tx.get() )
cond.outColorR >> jnt01.tx
cond.outColorG >> jnt02.tx
def focusRig():
currentSelection = pmc.selected()
warningMsg = "Please make a valid selection, first camera and then focus geometry!"
if len(currentSelection) != 2:
return pmc.displayWarning(warningMsg)
cameraTransform, focusTransform = currentSelection
cameraShape = cameraTransform.getShape()
if cameraShape.type() != "camera":
return pmc.displayWarning(warningMsg)
distance = pmc.distanceDimension(sp=focusTransform.getRotatePivot(space='world'),
ep=cameraTransform.getRotatePivot(space='world'))
distance.rename('lsFocusRigShape')
distance.getParent().rename('lsFocusRig')
focusLocator, nodalLocator = distance.listConnections()
focusLocator.rename('lsFocusPoint')
nodalLocator.rename('lsCameraNodal')
pmc.parent(nodalLocator, cameraTransform)
pmc.parent(distance.getParent(), cameraTransform)
# Needs to only continue if arnold is valid
if Renderer.isArnold:
cameraShape.aiEnableDOF.set(1)
cameraShape.aiApertureSize.set(1)
distance.distance >> cameraShape.aiFocusDistance
else:
cameraShape.depthOfField.set(1)
distance.distance >> cameraShape.focusDistance
def create_scale_distance(self):
self._MODEL.getScaleGrp = [adb.makeroot_func(grp, suff='scale', forceNameConvention=True) for grp in self.jointList]
for grp in self._MODEL.getScaleGrp:
self.MOD_GRP.sx >> grp.sx
self.MOD_GRP.sy >> grp.sy
self.MOD_GRP.sz >> grp.sz
distObjs_LIST_QDT = self.ribbon_ctrl
distanceNode_shape = pm.distanceDimension(sp=(1, 1, 1), ep=(2, 2, 2))
pm.rename(distanceNode_shape, 'bendy_scale_distDimShape')
pm.rename(pm.PyNode(distanceNode_shape).getParent(), 'bendy_scale_distDim')
distanceNode = (pm.PyNode(distanceNode_shape).getParent())
end_point_loc = pm.listConnections(str(distanceNode_shape) + '.endPoint', source=True)[0]
start_point_loc = pm.listConnections(str(distanceNode_shape) + '.startPoint', source=True)[0]
pm.rename(start_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[0], NC.LOC))
pm.rename(end_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[1], NC.LOC))
pm.matchTransform(start_point_loc, distObjs_LIST_QDT[0])
pm.matchTransform(end_point_loc, distObjs_LIST_QDT[1])
[loc.v.set(0) for loc in [end_point_loc, start_point_loc]]
self.scale_grp = pm.group(n='{}_scale__{}'.format(self.NAME, NC.GRP), w=True, em=True)
pm.parent(distanceNode, start_point_loc, end_point_loc, self.scale_grp)
self.scale_grp.v.set(0)
return distanceNode_shape
def directPlacementMode(card):
assert len(card.joints) == 3
grp = group(em=True, n='DirectPlacement_Deletable')
ctrls = []
for bpj in card.joints:
ctrl = tempWidget()
pdil.dagObj.matchTo(ctrl, bpj)
ctrls.append(ctrl)
ctrl.setParent(grp)
base, up, aim = ctrls
aimLoc = spaceLocator()
aimLoc.setParent(aim)
aimLoc.t.set(0, 0, 0)
baseLoc = spaceLocator()
baseLoc.setParent(base)
baseLoc.t.set(0, 0, 0)
dist = distanceDimension(baseLoc, aimLoc)
dist.getParent().setParent(grp)
hide(dist)
pointConstraint(base, card, mo=True)
aimConstraint(aim,
card,
wut='object',
wuo=up,
aim=[0, -1, 0],
u=[0, 0, -1],
mo=True)
# save base dimension
# current dimesion / base dimension
# multiply x, z by card's existing scale
dist.addAttr('baseDist', at='double', dv=dist.distance.get())
scaled = pdil.math.divide(dist.distance, dist.baseDist)
mult = createNode('multiplyDivide')
scaled >> mult.input1X
scaled >> mult.input1Y
scaled >> mult.input1Z
mult.input2Y.set(card.sy.get())
mult.input2Z.set(card.sz.get())
mult.outputY >> card.sy
mult.outputZ >> card.sz
pointConstraint(up, card.joints[1], sk='x')
def createDistanceTool(objA=None, objB=None):
""" A better version of Maya's Distance Tool """
if objA == None and objB == None:
objA, objB = getSelection(2)
elif objA == None or objB == None:
raise SelectionError("Incorrect Selection!")
spPos = getPosition(objA)
epPos = getPosition(objB)
distanceNode = pm.distanceDimension(sp=spPos, ep=epPos)
locSp = pm.listConnections(str(distanceNode) + ".startPoint")[0]
locEp = pm.listConnections(str(distanceNode) + ".endPoint")[0]
return [locSp, locEp]
def create_height_measure( feet=0, inches=0, scale=.1, name=False ):
'''
usage:
create_height_measure( feet=5, inches=11, name='maleRunnerB' )
'''
pm.select(cl=True)
in_to_cm = 2.54
inches += feet * 12
height = (inches * in_to_cm) * scale
distance_nodes = pm.distanceDimension( sp=[0,0,0], ep=[0, height, 0] )
return pm.group(distance_nodes, name=name)
def __init__(self, ikHandle, ikCtrl, doFlexyplane=True):
ikHandle = pm.ls(ikHandle)[0]
ikCtrl = pm.ls(ikCtrl)[0]
prefix = name.removeSuffix(ikHandle.name())
jointList = pm.ikHandle(ikHandle, jointList=True, q=True)
endJoint = pm.listRelatives(jointList[-1], c=True, type='joint')[0]
jointList.append(endJoint)
distanceDimensionShape = pm.distanceDimension(sp=jointList[0].getTranslation(space='world'),
ep=jointList[-1].getTranslation(space='world'))
locators = pm.listConnections(distanceDimensionShape, s=True)
startLoc = pm.rename(locators[0], prefix + 'DistanceStart_LOC')
endLoc = pm.rename(locators[1], prefix + 'DistanceEnd_LOC')
pm.pointConstraint(jointList[0], startLoc)
pm.pointConstraint(ikCtrl, endLoc)
# multiplyDivide Node
multiplyDivideNode = pm.shadingNode('multiplyDivide', asUtility=True, n=prefix + '_multiplyDivide')
multiplyDivideNode.input2X.set(1)
multiplyDivideNode.operation.set(2)
pm.connectAttr(distanceDimensionShape.distance, multiplyDivideNode.input1X, f=True)
distance = 0
for i in range(0, len(jointList[:-1])):
distance = distance + util.get_distance(jointList[i], jointList[i + 1])
multiplyDivideNode.input2X.set(distance)
# condition Node
conditionNode = pm.shadingNode('condition', asUtility=True, n=prefix + '_condition')
conditionNode.operation.set(2)
pm.connectAttr(distanceDimensionShape.distance, conditionNode.firstTerm, f=True)
pm.connectAttr(multiplyDivideNode.input2X, conditionNode.secondTerm, f=True)
pm.connectAttr(multiplyDivideNode.outputX, conditionNode.colorIfTrueR, f=True)
for jnt in jointList[:-1]:
pm.connectAttr(conditionNode.outColorR, jnt.scaleX, f=True)
self.stretchyGrp = pm.group(startLoc, endLoc, distanceDimensionShape.getParent(), n=prefix+'Stretchy_GRP')
self.stretchyGrp.visibility.set(0)
# save attributes
self.prefix = prefix
self.jointList = jointList
if doFlexyplane:
self.doFlexyPlane(prefix)
def creatDist():
sel = pm.ls(sl=True)
print sel
distNodeShape = pm.distanceDimension(sp=[0, 0, 0], ep=[0, 50, 0])
distNode = pm.listRelatives(distNodeShape, fullPath=True, parent=True)
print distNode
locs = pm.listConnections(distNodeShape, s=True)
print locs
pm.rename(locs[0], (sel[0].name() + "_dist_loc1"))
pm.rename(locs[1], (sel[1].name() + "_dist_loc2"))
pm.rename(distNode, (sel[0].name() + "_dist"))
pm.pointConstraint(sel[1], locs[1], w=True)
pm.pointConstraint(sel[0], locs[0], w=True)
def creatDist():
sel = pm.ls(sl = True)
print sel
distNodeShape = pm.distanceDimension(sp = [0,0,0], ep = [0,50,0])
distNode = pm.listRelatives(distNodeShape, fullPath = True, parent = True)
print distNode
locs = pm.listConnections(distNodeShape, s = True)
print locs
pm.rename(locs[0], (sel[0].name() + "_dist_loc1"))
pm.rename(locs[1], (sel[1].name() + "_dist_loc2"))
pm.rename(distNode, (sel[0].name() + "_dist"))
pm.pointConstraint(sel[1], locs[1], w = True)
pm.pointConstraint(sel[0], locs[0], w = True)
def rollingWheel(forwardAxis="translateZ",
rotationAxis="rotateX",
centerPosObj='',
bottomPosObj='',
rollingObject='',
controller='',
suffix="roll"):
""" gets radius from bottom and center,
uses the translate of controller to move forward,
attaching rotation to rollingObject
bug: can only move in a single direction.
"""
if not centerPosObj and bottomPosObj and rollingObject and controller:
logger.info('Arguments not satisfied')
return
#create nodes
piNode = pm.shadingNode('multiplyDivide',
asUtility=True,
n=suffix + '_pi_md')
distanceNode = pm.shadingNode('multiplyDivide',
asUtility=True,
n=suffix + '_distance_md')
fwdNode = pm.shadingNode('multiplyDivide',
asUtility=True,
n=suffix + '_fwd_md')
degreeRotNode = pm.shadingNode('multiplyDivide',
asUtility=True,
n=suffix + '_degreeRot_md')
distanceDimensionNode = pm.distanceDimension(
sp=(centerPosObj.getTranslation()), ep=(bottomPosObj.getTranslation()))
#set initial inputs
degreeRotNode.setAttr('input2X', -360)
piNode.setAttr('input2X', 3.14)
distanceNode.setAttr('input2X', 2)
fwdNode.setAttr('operation', 2)
#connectInputs
distanceDimensionNode.connectAttr('distance', distanceNode.input1X)
distanceNode.connectAttr('outputX', piNode.input1X)
piNode.connectAttr('outputX', fwdNode.input2X)
fwdNode.connectAttr('outputX', degreeRotNode.input1X)
controller.connectAttr(forwardAxis, fwdNode.input1X)
degreeRotNode.connectAttr('outputX', rollingObject + '.' + rotationAxis)
def creatDist(sel = None):
if not sel:
sel = pm.ls(sl = True)
if len(sel) == 2:
distNodeShape = pm.distanceDimension(sp = [0,0,0], ep = [0,50,0])
distNode = pm.listRelatives(distNodeShape, fullPath = True, parent = True)
locs = pm.listConnections(distNodeShape, s = True)
pm.rename(locs[0], (sel[0].name() + "_dist_loc1"))
pm.rename(locs[1], (sel[1].name() + "_dist_loc2"))
pm.rename(distNode, (sel[0].name() + "_dist"))
pm.pointConstraint(sel[1], locs[1], w = True)
pm.pointConstraint(sel[0], locs[0], w = True)
return distNodeShape, locs
else:
om.MGlobal_displayError('non conform selection')
def measure(start, end, name='measureLocs'):
'''
Given 2 objects, makes and point constrains locators to them and measures.
'''
a = spaceLocator()
pointConstraint(start, a)
b = spaceLocator()
pointConstraint(end, b)
dist = distanceDimension(a, b)
hide(a, b, dist)
grp = group(em=True, name=name)
grp.inheritsTransform.set(False)
a.setParent(grp)
b.setParent(grp)
return dist.getParent(), grp
def measure(start, end, name='measureLocs'):
'''
Given 2 objects, makes and point constrains locators to them and measures.
.. todo:: Should this be combined with `distanceBetween`?
#--# was skeleton.util.measure
'''
a = spaceLocator()
pointConstraint(start, a)
b = spaceLocator()
pointConstraint(end, b)
dist = distanceDimension(a, b)
#a.setParent( dist.getParent() )
#b.setParent( dist.getParent() )
hide(a, b, dist)
return dist.getParent(), group(a, b, name=name)
def stretchyIKSetUp(self):
"""
Creates a stretch system for an arm or leg
"""
# -----------------------------------
# FUNCTION
# -----------------------------------
def createloc(sub=pm.selected()):
"""Creates locator at the Pivot of the object selected """
locs = []
for sel in sub:
loc_align = pm.spaceLocator(n='{}_Distance__{}'.format(
NC.getNameNoSuffix(sel), NC.LOC))
locs.append(loc_align)
pm.matchTransform(loc_align, sel, rot=True, pos=True)
pm.select(locs, add=True)
return locs
self.posLoc = createloc([self.startJnt, self.endJnt])
sp = (pm.PyNode(self.posLoc[0]).translateX.get(),
pm.PyNode(self.posLoc[0]).translateY.get(),
pm.PyNode(self.posLoc[0]).translateZ.get())
ep = (pm.PyNode(self.posLoc[1]).translateX.get(),
pm.PyNode(self.posLoc[1]).translateY.get(),
pm.PyNode(self.posLoc[1]).translateZ.get())
# -----------------------------------
# IK STRETCH BUILD
# -----------------------------------
# create Nodes
self.distanceLoc = pm.distanceDimension(sp=sp, ep=ep)
self.orig_distance = self.distanceLoc.distance.get()
# getMaxdistance
def getMaxDistance():
oriTranslate = self.ik_ctrl.getTranslation()
pm.move(self.ik_ctrl, -1000, -1000, 0)
_max_distance = self.distanceLoc.distance.get()
self.ik_ctrl.setTranslation(oriTranslate)
return _max_distance
max_distance = getMaxDistance() + 0.2
# condition node
self.cond_node = pm.shadingNode('condition',
asUtility=1,
n='{}_cond_{}'.format(
self.NAME, NC.CONDITION_SUFFIX))
self.cond_node.operation.set(3)
self.cond_node.colorIfFalseR.set(1)
self.cond_node.secondTerm.set(1)
# blendColor node Toggle
self.toggle_node = pm.shadingNode('blendColors',
asUtility=1,
n='{}_Toggle__{}'.format(
self.NAME, NC.BLENDCOLOR_SUFFIX))
self.toggle_node.blender.set(1)
# multiply Divide strech
self.md_strech_node = pm.shadingNode('multiplyDivide',
asUtility=1,
n='{}_strech__MD'.format(
self.NAME,
NC.MULTIPLY_DIVIDE_SUFFIX))
self.md_strech_node.operation.set(1)
# multiply Divide Scale Factor
self.md_scale_node = pm.shadingNode('multiplyDivide',
asUtility=1,
n='{}_scaleFactor__{}'.format(
self.NAME,
NC.MULTIPLY_DIVIDE_SUFFIX))
self.md_scale_node.operation.set(1)
self.md_scale_node.input2X.set(max_distance)
self.MOD_GRP.sx >> self.md_scale_node.input1X
# multiply Divide proportion
self.md_prp_node = pm.shadingNode('multiplyDivide',
asUtility=1,
n='{}_proportion__{}'.format(
self.NAME,
NC.MULTIPLY_DIVIDE_SUFFIX))
self.md_prp_node.operation.set(2)
adb.makeroot_func(self.posLoc[1], suff='OFFSET', forceNameConvention=1)
# connections
self.distanceLoc.distance >> self.toggle_node.color1R
self.toggle_node.outputR >> self.md_prp_node.input1X
self.md_prp_node.outputX >> self.cond_node.firstTerm
self.md_prp_node.outputX >> self.cond_node.colorIfTrueR
self.md_scale_node.outputX >> self.md_prp_node.input2X
self.cond_node.outColorR >> self.md_strech_node.input1X
self.cond_node.outColorR >> self.md_strech_node.input1Y
self.md_strech_node.outputX >> pm.PyNode(
self.startJnt) + '.scale' + str(self.stretchAxis)
for joint in self.hingeJnts:
self.md_strech_node.outputX >> pm.PyNode(joint) + '.scale' + str(
self.stretchAxis)
# Clean up
self.posLoc[0].v.set(0)
self.posLoc[1].v.set(0)
self.distanceLoc.getParent().v.set(0)
def MakeIkStretchy( ikh=None, elbowLock=True ):
if ikh==None:
ikh = pm.ls(sl=True)[0]
locs = []
dists = []
# find joints connected to ikh
mustStrechJnts = ikh.getJointList()
endEffector = ikh.getEndEffector()
if len(mustStrechJnts) > 1 : # more than one joint, meaning RPSolver
# positions
uplegPos = WorldPos(mustStrechJnts[0])
kneePos = WorldPos(mustStrechJnts[1])
kneeEndPos = WorldPos(endEffector)
# create locators and distance nodes
uplegLoc = pm.spaceLocator()
pm.rename( uplegLoc, "%s_stretch_start_loc"% ikh.name() )
uplegLoc.translate.set( uplegPos )
kneeLoc = pm.spaceLocator()
pm.rename( uplegLoc, "%s_stretch_mid_loc"% ikh.name() )
kneeLoc.translate.set( kneePos )
kneeEndLoc = pm.spaceLocator()
kneeEndLoc.translate.set( kneeEndPos )
pm.rename( uplegLoc, "%s_stretch_end_loc"% ikh.name() )
locs.append(uplegLoc)
locs.append(kneeLoc)
locs.append(kneeEndLoc)
pm.select(uplegLoc, kneeLoc)
uplegDistShape = pm.distanceDimension ()
pm.select(kneeLoc, kneeEndLoc)
kneeDistShape = pm.distanceDimension ()
pm.select(uplegLoc, kneeEndLoc)
legDistShape = pm.distanceDimension ()
uplegDist = uplegDistShape.getParent()
kneeDist = kneeDistShape.getParent()
legDist = legDistShape.getParent()
dists.append(uplegDist)
dists.append(kneeDist)
dists.append(legDist)
pm.parent ( ikh , kneeEndLoc )
# make ik joints stretchy
defaultIKLegLen = uplegDistShape.distance.get() + kneeDistShape.distance.get()
stretch_mdn = pm.createNode ("multiplyDivide" , n = "%s_stretch_mdn" % ( ikh.name() ) )
stretch_mdn.input2X.set( defaultIKLegLen )
legDistShape.distance >> stretch_mdn.input1X
stretch_mdn.operation.set(2)
stretch_cnd = pm.createNode ("condition" , n = "%s_stretch_cnd"% ( ikh.name() ) )
legDistShape.distance >> stretch_cnd.firstTerm
stretch_cnd.secondTerm.set(defaultIKLegLen)
stretch_cnd.operation.set(2)
stretch_mdn.outputX >> stretch_cnd.colorIfTrueR
# stretch switch
stretchSwitch_bln = pm.createNode ("blendColors" , n = "%s_stretchSwitch_bln" % ( ikh.name() ) )
stretch_cnd.outColorR >> stretchSwitch_bln.color1R
stretchSwitch_bln.color2R.set(1)
# conncet result
for jnt in mustStrechJnts:
stretchSwitch_bln.outputR >> jnt.scaleX
# create swtich attribute on last locator
pm.addAttr(kneeEndLoc, keyable=True, attributeType="double", min=0, max=1, defaultValue=1, longName="stretchable")
kneeEndLoc.stretchable >> stretchSwitch_bln.blender
#================================================================================
# Elbow Lock
if elbowLock==True:
pm.addAttr ( kneeLoc ,dv = 0 ,min=0 ,max=10 , keyable = True , ln = "elbowLock" , at = "double")
defaultIKUpArmLen = pm.getAttr ( uplegDist.distance )
elbowLock_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLock_mdn" )
pm.setAttr ( elbowLock_mdn.input2X, defaultIKUpArmLen )
uplegDist.distance >> elbowLock_mdn.input1X
pm.setAttr ( elbowLock_mdn.operation, 2 )
defaultIKElbowLen = pm.getAttr ( kneeDist.distance )
IKelbowLock_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLock_mdn" )
pm.setAttr ( IKelbowLock_mdn.input2X, defaultIKElbowLen )
kneeDist.distance >> IKelbowLock_mdn.input1X
pm.setAttr ( IKelbowLock_mdn.operation, 2 )
#================================================================================
# make elbowLock more animation friendly by dividing it by 10
elbowLockAnimFriend_mdn = pm.createNode ("multiplyDivide" , n = ikh.name() + "_elbowLockAnimFriend_mdn" )
pm.setAttr ( elbowLockAnimFriend_mdn.input2X, 10 )
pm.setAttr ( elbowLockAnimFriend_mdn.operation, 2 )
kneeLoc.attr ( "elbowLock" ) >> elbowLockAnimFriend_mdn.input1X
#================================================================================
# conncet result of stretch and elbow lock to joint with a blend switch on the elbow locator
stretchUparmLock_bta = pm.createNode ("blendTwoAttr" , n = ikh.name() + "_stretchUparmLock_bta" )
elbowLockAnimFriend_mdn.outputX >> stretchUparmLock_bta.attributesBlender
stretchSwitch_bln.outputR >> stretchUparmLock_bta.input[0]
elbowLock_mdn.outputX >> stretchUparmLock_bta.input[1]
stretchUparmLock_bta.output >> mustStrechJnts[0].scaleX
stretchElbowLock_bta = pm.createNode ("blendTwoAttr" , n = ikh.name() + "_stretchElbowLock_bta" )
elbowLockAnimFriend_mdn.outputX >> stretchElbowLock_bta.attributesBlender
stretchSwitch_bln.outputR >> stretchElbowLock_bta.input[0]
IKelbowLock_mdn.outputX >> stretchElbowLock_bta.input[1]
stretchElbowLock_bta.output >> mustStrechJnts[1].scaleX
elif len(mustStrechJnts) == 1 : # one jnt meaning SCSolver
# positions
uplegPos = WorldPos(mustStrechJnts[0])
kneeEndPos = WorldPos(endEffector)
# create locators and distance nodes
uplegLoc = pm.spaceLocator()
uplegLoc.translate.set( uplegPos )
kneeEndLoc = pm.spaceLocator()
kneeEndLoc.translate.set( kneeEndPos )
locs.append(uplegLoc)
locs.append(kneeEndLoc)
pm.select(uplegLoc, kneeEndLoc)
legDistShape = pm.distanceDimension ()
legDist = legDistShape.getParent()
dists.append(legDist)
pm.parent ( ikh , kneeEndLoc )
# make ik joints stretchy
defaultIKLegLen = legDistShape.distance.get()
stretch_mdn = pm.createNode ("multiplyDivide" , n = "%s_stretch_mdn" % ( ikh.name() ) )
stretch_mdn.input2X.set( defaultIKLegLen )
legDistShape.distance >> stretch_mdn.input1X
stretch_mdn.operation.set(2)
# stretch switch
stretchSwitch_bln = pm.createNode ("blendColors" , n = "%s_stretchSwitch_bln" % ( ikh.name() ) )
stretch_mdn.outputX >> stretchSwitch_bln.color1R
stretchSwitch_bln.color2R.set(1)
# conncet result
for jnt in mustStrechJnts:
stretchSwitch_bln.outputR >> jnt.scaleX
# create swtich attribute on last locator
pm.addAttr(kneeEndLoc, keyable=True, attributeType="double", min=0, max=1, defaultValue=1, longName="stretchable")
kneeEndLoc.stretchable >> stretchSwitch_bln.blender
return ( locs, dists)
def IK_Stretch(*args):
joint_selected = pm.ls(sl=True)
joint_start = joint_selected[0]
joint_end = joint_selected[1]
textFieldData_ik_suffix = pm.textField(textFieldEntry_ik_suffix,
editable=True,
query=True,
text=True)
ik_suffix = textFieldData_ik_suffix
num_name_delete = pm.intField(intFieldEntry_num_name_delete,
editable=True,
query=True,
value=True)
newname = joint_start.split('_')
print newname
number_name = len(newname)
new_name_first = newname[0] + '_'
for i in range(0, number_name):
if i > number_name - num_name_delete - 1 or i == number_name - num_name_delete - 1:
new_name_ik = new_name_first
print 'naming error'
break
else:
if i < number_name - num_name_delete - 1:
new_name_second = newname[i + 1] + '_'
new_name_ik = new_name_first + new_name_second
new_name_first = new_name_ik
else:
break
pm.ikHandle(sj=joint_start,
ee=joint_end,
n='{0}ik_handle'.format(new_name_ik))
if pm.objExists('dist_loc_01'):
print 'dist_loc_01 exists'
else:
dist_loc_01 = pm.spaceLocator(n='dist_loc_01')
for i in range(0, 20):
if i == 0:
pm.select(joint_start)
joint_parent = pm.listRelatives(p=True, type='joint')
elif i > 0:
pm.select(joint_parent)
joint_first = pm.ls(sl=True)
joint_parent = pm.listRelatives(p=True, type='joint')
if joint_parent == []:
pm.select(joint_first)
joint_first_select = pm.ls(sl=True)
break
else:
continue
pm.select(joint_first_select, hi=True)
all_hierachy = pm.ls(sl=True)
pm.select(joint_start)
joint_mid = pm.listRelatives(c=True)
pm.select(dist_loc_01, joint_start)
snapping()
pm.select(dist_loc_01, joint_mid)
snapping()
pm.select(dist_loc_01, joint_end)
snapping()
pm.select(joint_start, joint_mid, joint_end)
ik_joint_loc = pm.ls(sl=True)
pm.select(d=True)
for n in ik_joint_loc:
newname = n.split('_')
print newname
number_name = len(newname)
new_name_first = newname[0] + '_'
for i in range(0, number_name):
if i > number_name - num_name_delete - 1 or i == number_name - num_name_delete - 1:
new_name = new_name_first
print 'naming error'
break
else:
if i < number_name - num_name_delete - 1:
new_name_second = newname[i + 1] + '_'
new_name = new_name_first + new_name_second
new_name_first = new_name
else:
break
print new_name
pm.select('{0}{1}'.format(new_name, ik_suffix), add=True)
dist_loc_all = pm.ls(sl=True)
dist_loc_start = dist_loc_all[0]
dist_loc_mid = dist_loc_all[1]
dist_loc_end = dist_loc_all[2]
pm.pointConstraint('{0}'.format(dist_loc_start), joint_start, mo=True, w=1)
pm.pointConstraint(joint_mid, '{0}_pad'.format(dist_loc_mid), mo=True, w=1)
pm.pointConstraint('{0}'.format(dist_loc_end),
'{0}ik_handle'.format(new_name_ik),
mo=True,
w=1)
dist_loc_start_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_start))
dist_loc_start_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_start))
dist_loc_start_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_start))
dist_loc_mid_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_mid))
dist_loc_mid_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_mid))
dist_loc_mid_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_mid))
dist_loc_end_tx = pm.getAttr('{0}_pad.tx'.format(dist_loc_end))
dist_loc_end_ty = pm.getAttr('{0}_pad.ty'.format(dist_loc_end))
dist_loc_end_tz = pm.getAttr('{0}_pad.tz'.format(dist_loc_end))
dist_dimension_name()
pm.distanceDimension(sp=(dist_loc_start_tx, dist_loc_start_ty,
dist_loc_start_tz),
ep=(dist_loc_mid_tx, dist_loc_mid_ty,
dist_loc_mid_tz))
newname = dist_loc_start.split('_')
print newname
number_name = len(newname)
new_name_first = newname[0] + '_'
for i in range(0, number_name):
if i > number_name - num_name_delete - 2 or i == number_name - num_name_delete - 2:
new_name = new_name_first
print 'naming error'
break
else:
if i < number_name - num_name_delete - 2:
new_name_second = newname[i + 1] + '_'
new_name = new_name_first + new_name_second
new_name_first = new_name
else:
break
dist_measure_01 = pm.rename(dist_dimension_created,
'{0}01_dist'.format(new_name))
dist_dimension_name()
pm.distanceDimension(sp=(dist_loc_mid_tx, dist_loc_mid_ty,
dist_loc_mid_tz),
ep=(dist_loc_end_tx, dist_loc_end_ty,
dist_loc_end_tz))
dist_measure_02 = pm.rename(dist_dimension_created,
'{0}02_dist'.format(new_name))
dist_dimension_name()
pm.distanceDimension(sp=(dist_loc_start_tx, dist_loc_start_ty,
dist_loc_start_tz),
ep=(dist_loc_end_tx, dist_loc_end_ty,
dist_loc_end_tz))
actual_length_ik = pm.rename(dist_dimension_created,
'{0}dist'.format(new_name))
first_length_ik = pm.getAttr('{0}.distance'.format(dist_measure_01))
second_length_ik = pm.getAttr('{0}.distance'.format(dist_measure_02))
max_length_ik = first_length_ik + second_length_ik
ratio_ik_stretch = pm.createNode('multiplyDivide',
n='{0}ratio_ik_stretch'.format(new_name))
pm.setAttr('{0}.operation'.format(ratio_ik_stretch), 2)
pm.connectAttr('{0}.distance'.format(actual_length_ik),
'{0}.input1X'.format(ratio_ik_stretch))
pm.setAttr('{0}.input2X'.format(ratio_ik_stretch), max_length_ik)
ratio_ik_stretch_cond = pm.createNode(
'condition', n='{0}ratio_ik_stretch_cond'.format(new_name))
pm.connectAttr('{0}.outputX'.format(ratio_ik_stretch),
'{0}.firstTerm'.format(ratio_ik_stretch_cond))
pm.connectAttr('{0}.outputX'.format(ratio_ik_stretch),
'{0}.colorIfTrueR'.format(ratio_ik_stretch_cond))
pm.setAttr('{0}.operation'.format(ratio_ik_stretch_cond), 3)
pm.setAttr('{0}.secondTerm'.format(ratio_ik_stretch_cond), 1)
pm.setAttr('{0}.colorIfFalseR'.format(ratio_ik_stretch_cond), 1)
pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond),
'{0}.scaleX'.format(joint_start))
pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond),
'{0}.scaleX'.format(joint_mid[0]))
pm.connectAttr('{0}.outColorR'.format(ratio_ik_stretch_cond),
'{0}.scaleX'.format(joint_end))
pm.delete(dist_loc_01)
q=True,
ws=True,
rotatePivot=True)
shadow_height_ratio = get_distance(shadow_start_location,
shadow_end_location)
print shadow_height_ratio
shadow_cylinder[0].rotatePivot.set([-0.5 * shadow_height_ratio, 0, 0])
shadow_cylinder[0].scalePivot.set([-0.5 * shadow_height_ratio, 0, 0])
shadow_cylinder[1].heightRatio.set(shadow_height_ratio / shadow_radius)
else:
pass
pm.matchTransform(shadow_cylinder, shadow_start, scale=False)
aim_object(aimer, target, axis='+x')
#pm.move(shadow_cylinder, [-1.15381, 1.627506, 0.141238], relative = True, rotatePivotRelative = 1, scalePivotRelative = 1)
print(
pm.distanceDimension(startPoint=shadow_start_location,
endPoint=shadow_end_location))
#set shadow_length
import math
def get_distance(startPoint, endPoint):
dx = startPoint[0] - endPoint[0]
dy = startPoint[1] - endPoint[1]
dz = startPoint[2] - endPoint[2]
return math.sqrt(dx * dx + dy * dy + dz * dz)
def CreateNodes(self):
"""Creation et settings de mes nodes"""
def createloc(sub):
"""Creates locator at the Pivot of the object selected """
locs = []
for sel in sub:
loc_align = pm.spaceLocator(n='{}__pos_loc__'.format(sel))
locs.append(loc_align)
pm.matchTransform(loc_align, sel, rot=True, pos=True)
pm.select(locs, add=True)
return locs
self.CurveInfoNode = None
posLocs = []
if self.usingCurve:
self.spineLenghtCurve = adb.createCurveFrom(self.jointList, curve_name='{}_lenght__CRV'.format(self.NAME))
pm.parent(self.spineLenghtCurve, self.RIG_GRP)
self.CurveInfoNode = pm.shadingNode('curveInfo', asUtility=1, n='{}_CurveInfo'.format(self.NAME))
else:
posLocs = createloc([self.jointList[0], self.jointList[-1]])
sp = (pm.PyNode(posLocs[0]).translateX.get(), pm.PyNode(posLocs[0]).translateY.get(), pm.PyNode(posLocs[0]).translateZ.get())
ep = (pm.PyNode(posLocs[1]).translateX.get(), pm.PyNode(posLocs[1]).translateY.get(), pm.PyNode(posLocs[1]).translateZ.get())
# create Distances Nodes
self.DistanceLoc = pm.distanceDimension(sp=sp, ep=ep)
pm.rename(self.DistanceLoc, 'bendy_distDimShape')
pm.rename(pm.PyNode(self.DistanceLoc).getParent(), 'bendy_distDim')
distance = self.DistanceLoc.distance.get()
pm.parent(self.DistanceLoc.getParent(), self.RIG_GRP)
pm.parent(posLocs[0], self.ribbon_ctrl[0])
pm.parent(posLocs[1], self.ribbon_ctrl[1])
pm.rename(posLocs[0], 'distance_depart__{}'.format(NC.LOC))
pm.rename(posLocs[1], 'distance_end__{}'.format(NC.LOC))
posLocs[0].v.set(0)
posLocs[1].v.set(0)
self.DistanceLoc.getParent().v.set(0)
# Creation des nodes Multiply Divide
self.Stretch_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="StretchMult")
self.Squash_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="SquashMult")
self.expA_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpA".format(self.NAME))
self.expB_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpB".format(self.NAME))
self.expC_MD = pm.shadingNode('multiplyDivide', asUtility=1, n="{}_ExpC".format(self.NAME))
# blendColor node Toggle
self.toggle_node = pm.shadingNode('blendColors', asUtility=1, n='{}_Toggle__{}'.format(self.NAME, NC.BLENDCOLOR_SUFFIX))
self.toggle_node.blender.set(1)
# Settings des nodes Multiply Divide
self.Stretch_MD.operation.set(2)
self.Squash_MD.operation.set(2)
self.expA_MD.operation.set(3)
self.expA_MD.input1X.set(1)
self.expB_MD.operation.set(3)
self.expB_MD.input1X.set(1)
self.expC_MD.operation.set(3)
self.expC_MD.input1X.set(1)
return self.expA_MD, self.expB_MD, self.expC_MD, self.Squash_MD, self.Stretch_MD, self.CurveInfoNode, posLocs
def __init__(self, **kwds):
self.name = defaultReturn('rig_measure', 'name', param=kwds)
self.start = defaultReturn(None, 'start', param=kwds)
self.end = defaultReturn(None, 'end', param=kwds)
self.parent = defaultReturn(None, 'parent', param=kwds)
startConstrainer = self.start
endConstrainer = self.end
self.start = rig_transform( 0, name=self.name+'Start', type='locator', target=self.start ).object
self.end = rig_transform( 0, name=self.name+'End', type='locator', target=self.end ).object
pm.move(self.end, 0, 10, 0, r=True, os=True)
#startAttr = pm.getAttr( self.start+'.translate' )
startAttr = pm.xform(self.start, translation=True, query=True, ws=True)
#endAttr = pm.getAttr( self.end+'.translate' )
endAttr = pm.xform(self.end, translation=True, query=True, ws=True)
self.shape = pm.distanceDimension(sp=startAttr, ep=endAttr)
pm.move(self.end, 0, -10, 0, r=True, os=True)
pm.rename(self.shape, self.name+'_distanceShape')
self.distance = pm.rename(pm.listRelatives(self.shape, p=True)[0], self.name+'_distance')
pm.pointConstraint( startConstrainer , self.start )
pm.pointConstraint( endConstrainer , self.end )
self.distanceVal = pm.getAttr(self.distance.distance)
pm.addAttr(self.distance, longName='originalLength',
at='float', k=True, dv=self.distanceVal )
self.distance.originalLength.set(cb=True)
pm.addAttr(self.distance, longName='globalOriginalLength',
at='float', k=True, dv=self.distanceVal)
self.distance.globalOriginalLength.set(cb=True)
pm.addAttr(self.distance, longName='originalPercent',
at='float', k=True, dv=1)
self.distance.originalPercent.set(cb=True)
pm.addAttr(self.distance, longName='globalOriginalPercent',
at='float', k=True, dv=1)
self.distance.globalOriginalPercent.set(cb=True)
'''
measurePnct = multiplyDivideNode(self.name + '_measurepcnt', 'divide',
input1=[self.distance.distance,self.distance.distance, 1],
input2=[self.distance.originalLength,self.distance.globalOriginalLength, 1],
output=[self.distance.originalPercent, self.distance.globalOriginalPercent])
'''
measurePnct = multiplyDivideNode(self.name + '_measurepcnt', 'divide',
input1=[self.distance.distance, self.distance.distance, 1],
input2=[1, 1, 1],
output=[self.distance.originalPercent,
self.distance.globalOriginalPercent])
# make 0.001 the minimum
originalMin_con = conditionNode(self.name + '_origZeroMin', 'equal',
(self.distance, 'originalLength' ), ('', 0 ),
( '', 0.001 ),
( self.distance, 'originalLength' ))
globalOriginalMin_con = conditionNode(self.name + '_globalOrigZeroMin', 'equal',
(self.distance, 'globalOriginalLength' ), ('', 0 ),
( '', 0.001 ),
( self.distance, 'globalOriginalLength' ))
pm.connectAttr( originalMin_con+'.outColorR', measurePnct+'.input2X' )
pm.connectAttr( globalOriginalMin_con + '.outColorR', measurePnct + '.input2Y')
if pm.objExists('rig_GRP'):
multiplyDivideNode(self.name + '_globalOriginalLength', 'multiply',
input1=[self.distance.originalLength, 0, 0],
input2=['rig_GRP.worldScale', 0, 0],
output=[self.distance.globalOriginalLength])
if pm.objExists(self.parent):
pm.parent( self.distance, self.start, self.end ,self.parent )
def setup_ik_stretch_leg(jnts, RL='L'):
### TODO: consider global scale, stretch attribute on/off on ik Ctlr
### TODO: split up upper and lower leg stretch amound (as seen in AM steward)
# distance measure. 2 locators, parent foot and up_leg
dd = pm.distanceDimension(
sp=jnts['L_leg01']['ikJnt'].t.get(),
ep=jnts['L_foot01']['ctrlJnt'].t.get(),
)
pm.rename(dd.getParent(), '%s_leg_ik_dist' % RL)
start_loc = pm.spaceLocator(n='%s_leg_ik_startDist' % RL)
end_loc = pm.spaceLocator(n='%s_leg_ik_endDist' % RL)
pm.pointConstraint(jnts['L_leg01']['ikJnt'], start_loc)
pm.pointConstraint('%s_leg_ikHandle' % RL, end_loc)
# connect loc to distanceNode
start_loc.t >> dd.startPoint
end_loc.t >> dd.endPoint
riggUtils.grpIn('L_legikJnt_distGrp', [start_loc, end_loc])
log_debug('dist create done')
# sum_leg_tx to compare. ADD UP UP LOW DISTANCfE
leg02_tx_orig = pm.createNode('plusMinusAverage',
n='%s_leg02StrOrig_plsMns')
leg02_tx_orig.input1D[0].set(jnts['L_leg02']['ikJnt'].tx.get())
leg03_tx_orig = pm.createNode('plusMinusAverage',
n='%s_leg03StrOrig_plsMns')
leg03_tx_orig.input1D[1].set(jnts['L_leg03']['ikJnt'].tx.get())
leg_tx_orig = pm.createNode('plusMinusAverage', n='%s_legStrOrig_plsMns')
leg02_tx_orig.output1D >> leg_tx_orig.input1D[0]
leg03_tx_orig.output1D >> leg_tx_orig.input1D[1]
log_debug('summing up tx to compare done')
# divide dist node by summed
stretch_factor_mult = pm.createNode('multiplyDivide',
n='%s_legStrFactor_mult')
leg_tx_orig.output1D >> stretch_factor_mult.input2X
dd.distance >> stretch_factor_mult.input1X
stretch_factor_mult.operation.set(2)
log_debug('figure out distance multiplyer done')
# clamp output 1 to max stretch (don't want to go below 1, squash..)
clamp_stretch = pm.createNode('clamp', n='%s_legStr_clamp' % RL)
clamp_stretch.minR.set(1)
clamp_stretch.maxR.set(3)
# TODO: max stretch sett a attribute for it animator can adjust
stretch_factor_mult.outputX >> clamp_stretch.inputR
log_debug('clamp done')
# multiply tx fo leg02 and 03 with stretch
stretch_mult = pm.createNode('multiplyDivide', n='%s_legStr_mult')
clamp_stretch.outputR >> stretch_mult.input2X
clamp_stretch.outputR >> stretch_mult.input2Y
leg02_tx_orig.output1D >> stretch_mult.input1X
leg03_tx_orig.output1D >> stretch_mult.input1Y
log_debug('mult tx to leg 02/03 stretch done')
# now connect that to actual ikJnt TX
stretch_mult.outputX >> jnts['L_leg02']['ikJnt'].tx
stretch_mult.outputY >> jnts['L_leg03']['ikJnt'].tx
log_debug('connecting done')
def ikLimb( self, *args ):
print 'ehm_leg........................ikLimb'
#===============================================================================
# duplicate main leg joints and rename IK joints
self.IKJnts = pm.duplicate (self.upLegJnt )
pm.select (self.IKJnts[0])
self.IKJnts = SearchReplaceNames ( "jnt", "IK_jnt", self.IKJnts[0] )
#===============================================================================
# create ik handles
self.legIKStuff = pm.ikHandle( sj = self.IKJnts[0], ee = self.IKJnts[2], solver = "ikRPsolver" )
pm.rename (self.legIKStuff[0] , (self.side + "_leg_ikh") )
#===============================================================================
# distance nodes for stretching purpose
self.IKLegDist = pm.distanceDimension ( sp = self.upLegPos , ep = self.anklePos )
self.IKupLegDist = pm.distanceDimension ( sp = self.upLegPos , ep = self.kneePos )
self.IKKneeDist = pm.distanceDimension ( sp = self.kneePos , ep = self.anklePos )
self.IKLegDistT = pm.listRelatives ( self.IKLegDist , p=True)[0]
self.IKupLegDistT = pm.listRelatives ( self.IKupLegDist , p=True)[0]
self.IKKneeDistT = pm.listRelatives ( self.IKKneeDist , p=True)[0]
#===============================================================================
# find the leg locs from distance shape node
self.IKlegDistLocs = pm.listConnections (self.IKLegDist , plugs=False)
self.IKKneeDistLocs = pm.listConnections (self.IKKneeDist , plugs=False)
pm.rename (self.IKlegDistLocs[0] , self.side + "_upLeg_dist_loc" )
pm.rename (self.IKlegDistLocs[1] , self.side + "_ankle_dist_loc" )
pm.rename (self.IKKneeDistLocs[0] , self.side + "_knee_dist_loc" )
#===============================================================================
# parent ikHandle to ankle loc
pm.parent ( self.legIKStuff[0] , self.IKKneeDistLocs[1] )
#===============================================================================
# make ik joints stretchy
defaultIKLegLen = pm.getAttr ( self.IKupLegDist.distance ) + pm.getAttr ( self.IKKneeDist.distance )
self.IKLeg_stretch_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKLeg_stretch_mdn" )
pm.setAttr ( self.IKLeg_stretch_mdn.input2X, defaultIKLegLen )
self.IKLegDist.distance >> self.IKLeg_stretch_mdn.input1X
pm.setAttr ( self.IKLeg_stretch_mdn.operation, 2 )
self.IKLeg_stretch_cnd = pm.createNode ("condition" , n = self.side + "_IKLeg_stretch_cnd")
self.IKLegDist.distance >> self.IKLeg_stretch_cnd.firstTerm
pm.setAttr ( self.IKLeg_stretch_cnd.secondTerm , defaultIKLegLen )
pm.setAttr ( self.IKLeg_stretch_cnd.operation , 2 )
self.IKLeg_stretch_mdn.outputX >> self.IKLeg_stretch_cnd.colorIfTrueR
#================================================================================
# Knee Lock
pm.addAttr ( self.IKKneeDistLocs[0] ,dv = 0 ,min=0 ,max=10 , keyable = True , ln = "kneeLock" , at = "double")
defaultIKupLegLen = pm.getAttr ( self.IKupLegDist.distance )
self.IKupLeg_kneeLock_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKupLeg_kneeLock_mdn" )
pm.setAttr ( self.IKupLeg_kneeLock_mdn.input2X, defaultIKupLegLen )
self.IKupLegDist.distance >> self.IKupLeg_kneeLock_mdn.input1X
pm.setAttr ( self.IKupLeg_kneeLock_mdn.operation, 2 )
defaultIKKneeLen = pm.getAttr ( self.IKKneeDist.distance )
self.IKKnee_kneeLock_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKKnee_kneeLock_mdn" )
pm.setAttr ( self.IKKnee_kneeLock_mdn.input2X, defaultIKKneeLen )
self.IKKneeDist.distance >> self.IKKnee_kneeLock_mdn.input1X
pm.setAttr ( self.IKKnee_kneeLock_mdn.operation, 2 )
#================================================================================
# make kneeLock more animation friendly by dividing it by 10
self.IKLeg_kneeLockAnimFriend_mdn = pm.createNode ("multiplyDivide" , n = self.side + "_IKLeg_kneeLockAnimFriend_mdn" )
pm.setAttr ( self.IKLeg_kneeLockAnimFriend_mdn.input2X, 10 )
pm.setAttr ( self.IKLeg_kneeLockAnimFriend_mdn.operation, 2 )
self.IKKneeDistLocs[0].attr ( "kneeLock" ) >> self.IKLeg_kneeLockAnimFriend_mdn.input1X
#================================================================================
# conncet result of stretch and knee lock to joint with a blend switch on the knee locator
self.upLeg_stretchKneeLock_bta = pm.createNode ("blendTwoAttr" , n = self.side + "_upLeg_stretchKneeLock_bta" )
self.IKLeg_kneeLockAnimFriend_mdn.outputX >> self.upLeg_stretchKneeLock_bta.attributesBlender
self.IKLeg_stretch_cnd.outColorR >> self.upLeg_stretchKneeLock_bta.input[0]
self.IKupLeg_kneeLock_mdn.outputX >> self.upLeg_stretchKneeLock_bta.input[1]
self.knee_stretchKneeLock_bta = pm.createNode ("blendTwoAttr" , n = self.side + "_knee_stretchKneeLock_bta" )
self.IKLeg_kneeLockAnimFriend_mdn.outputX >> self.knee_stretchKneeLock_bta.attributesBlender
self.IKLeg_stretch_cnd.outColorR >> self.knee_stretchKneeLock_bta.input[0]
self.IKKnee_kneeLock_mdn.outputX >> self.knee_stretchKneeLock_bta.input[1]
self.upLeg_stretchKneeLock_bta.output >> self.IKJnts[0].scaleX
self.knee_stretchKneeLock_bta.output >> self.IKJnts[1].scaleX
#================================================================================
# force leg distance dimentions to be scalable by mainCtrl
DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKLegDist)
DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKupLegDist)
DistGlobalScale (mainCtrl=self.mainCtrl , dist=self.IKKneeDist)
# create IK ankle control curve with transforms of the ankle joint
self.ankleIKCtrl = CubeCrv( self.legSize*1.5 , self.side + "_ankle_IK_ctrl" )
pm.select ( self.ankleIKCtrl )
self.ankleIKCtrlZero = ZeroGrp()[0]
pm.parent ( self.ankleIKCtrlZero , self.IKJnts[2] )
self.ankleIKCtrlZero.translate.set( 0,0,0 )
# self.ankleIKCtrlZero.rotate.set( 0,0,0 )
pm.parent ( self.ankleIKCtrlZero , w=True )
pm.parent ( self.IKlegDistLocs[1] , self.ankleIKCtrl )
#============================================================================
# add attributes to leg_ctrl
pm.addAttr ( self.ankleIKCtrl , ln = "stretch_off_on" , at = "double" , min = 0 , max = 1 , dv = 1 , k = True )
pm.addAttr ( self.ankleIKCtrl , ln = "roll" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True )
pm.addAttr ( self.ankleIKCtrl , ln = "toe" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True )
pm.addAttr ( self.ankleIKCtrl , ln = "side_to_side" , at = "double" , min = -10 , max = 10 , dv = 0 , k = True )
#============================================================================
# create foot ik handles
self.toeIKStuff = pm.ikHandle( sj = self.IKJnts[2], ee = self.IKJnts[3], solver = "ikSCsolver" )
pm.rename(self.toeIKStuff[0], self.side + "_toe_ikh")
self.toeEndIKStuff = pm.ikHandle( sj = self.IKJnts[3], ee = self.IKJnts[4], solver = "ikSCsolver" )
pm.rename(self.toeEndIKStuff[0], "_toe_end_ikh")
#============================================================================
# foot ik groups and set driven keys
self.heelUpSdk = pm.group ( self.toeIKStuff[0] , self.IKlegDistLocs[1] , n = self.side + "_heel_up_sdk" )
pm.xform ( os= True , piv = self.toePos )
self.toeSdk = pm.group( self.toeEndIKStuff[0] , n = self.side + "_toe_sdk" )
pm.xform ( os= True , piv = self.toePos )
self.tipSdk = pm.group ( self.heelUpSdk , self.toeSdk , n = self.side + "_tip_sdk" )
pm.xform ( os= True , piv = ( self.toeEndPos[0] , 0 , self.toeEndPos[2] ) )
self.heelSdk = pm.group ( self.tipSdk , n = self.side + "_heel_sdk" )
pm.xform ( os= True , piv = ( self.heelPos[0] , 0 , self.heelPos[2] ) )
self.inFootSdk = pm.group ( self.heelSdk, n = self.side + "_in_foot_sdk" )
pm.xform ( os= True , piv = ( self.inPivPos[0] , 0 , self.inPivPos[2] ) )
self.outFootSdk = pm.group ( self.inFootSdk , n = self.side + "_out_foot_sdk" )
pm.xform ( os= True , piv = ( self.outPivPos[0] , 0 , self.outPivPos[2] ) )
pm.parent ( self.outFootSdk , self.ankleIKCtrl )
#============================================================================
# foot set driven keys
# toe set driven keys
pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = 0 , v = 0 )
pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = 10 , v = -45 )
pm.setDrivenKeyframe ( self.toeSdk.rotateX , currentDriver = self.ankleIKCtrl.toe , dv = -10 , v = 70 )
# roll set driven keys
pm.setDrivenKeyframe ( self.heelSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 )
pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 )
pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 0 , v = 0 )
pm.setDrivenKeyframe ( self.heelSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = 10 , v = -30 )
pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -10 , v = 45 )
pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -10 , v = 0 )
pm.setDrivenKeyframe ( self.tipSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -5 , v = 0 )
pm.setDrivenKeyframe ( self.heelUpSdk.rotateX , currentDriver = self.ankleIKCtrl.roll , dv = -5 , v = 30 )
#================================================================================
# create IK knee control curve
self.kneeIKCtrl = SoftSpiralCrv( self.legSize , self.side + "_knee_IK_ctrl" )
if self.side == "R" :
self.kneeIKCtrl.scale.scaleY.set (-1)
pm.makeIdentity (self.kneeIKCtrl , apply = True , t = 1 , r = 1 , s = 1 , n = 0)
pm.select ( self.kneeIKCtrl )
self.kneeIKCtrlZO = ZeroGrp()
pm.parent ( self.kneeIKCtrlZO[0] , self.IKJnts[1] )
self.kneeIKCtrlZO[0].translate.set( 0,0,0 )
#self.kneeIKCtrlZO[0].rotate.set( 0,0,0 )
pm.parent ( self.kneeIKCtrlZO[0] , w=True )
pm.parent ( self.IKKneeDistLocs[0] , self.kneeIKCtrl )
# direction of the knee ctrl is defined here. ????????????????????????????????
self.kneeIKCtrlZO[1].translate.set (0,0, self.legSize*3)
pm.poleVectorConstraint( self.IKKneeDistLocs[0] , self.legIKStuff[0] )
#===========
# pv guide curve
self.PVGuideCrv = pm.curve ( d = 1 ,
p = ( (self.kneePos) , (0,0,0 ) ) ,
k = (1,2) , name = self.side + "_PV_guide_crv" )
self.PVGuideStartJnt =pm.joint ( p = (self.kneePos) , name = ( self.side + "_PV_guide_start_jnt" ) )
pm.select (cl=True)
self.PVGuideEndJnt =pm.joint ( p = (0,0,0) , name = ( self.side + "_PV_guide_end_jnt" ) )
pm.skinCluster( self.PVGuideCrv , self.PVGuideStartJnt , self.PVGuideEndJnt , toSelectedBones = True )
pm.parent (self.PVGuideEndJnt , self.kneeIKCtrl)
self.PVGuideEndJnt.translate.set(0,0,0)
pm.setAttr ( self.PVGuideCrv.overrideEnabled , True)
pm.setAttr ( self.PVGuideCrv.overrideDisplayType , True)
pm.setAttr ( self.PVGuideCrv.inheritsTransform , False)
LockHideAttr ( objs=self.PVGuideStartJnt , attrs="vv")
LockHideAttr ( objs=self.PVGuideEndJnt , attrs="vv")
#================================================================================
# if just ik leg is needed then delete leg joints and us ik joints as leg joints
# this way we won't have extra result joint, just ik joints will remain in the scene
if self.FKIKMode == "IK" :
pm.delete (self.upLegJnt)
self.upLegJnt = self.IKJnts[0]
self.kneeJnt = self.IKJnts[1]
self.ankleJnt = self.IKJnts[2]
self.toeJnt = self.IKJnts[3]
def cardIk(card):
#ctrl = mel.eval( 'curve -d 1 -p -0.5 1 -0.866026 -p -0.5 1 0.866025 -p 1 1 0 -p -0.5 1 -0.866026 -p 0 0 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 0 0 0 -p -0.5 1 0.866025 -p 1 1 0 -p 0 0 0 -p 1 -1 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 1 -1 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 ;' )
ctrl = tempWidget()
ctrl.rename(card.name() + "_target")
upCtrl = duplicate(ctrl)[0]
upCtrl.rename(card.name() + "_up")
aim = spaceLocator()
aim.setParent(ctrl)
aim.t.set(0, 0, 0)
hide(aim)
up = spaceLocator()
up.setParent(upCtrl)
hide(up)
base = spaceLocator()
base.rename('cardIkBase')
hide(base)
pointConstraint(card, base)
pdil.dagObj.moveTo(ctrl, card.joints[-1])
#pdil.dagObj.moveTo( upCtrl, card.vtx[1] )
pdil.dagObj.moveTo(upCtrl, card.cv[1][0])
aimConstraint(aim,
card,
wut='object',
wuo=up,
aim=[0, -1, 0],
u=[0, 0, -1])
dist = distanceDimension(base, aim)
dist.getParent().setParent(ctrl)
hide(dist)
pdil.math.divide(dist.distance,
dist.distance.get() / card.sy.get()) >> card.sy
follower = spaceLocator()
follower.rename('cardIkFollower')
follower.setParent(card)
follower.t.set(0, 0, 0)
hide(follower)
pointConstraint(up, follower, skip=['x', 'z'])
sideDist = distanceDimension(follower, up)
sideDist.getParent().setParent(ctrl)
hide(sideDist)
pdil.math.divide(sideDist.distance,
sideDist.distance.get() / card.sz.get()) >> card.sz
# Orient controls with the card so moving in local space initially preserves orientation.
upCtrl.setRotation(card.getRotation(space='world'), space='world')
ctrl.setRotation(card.getRotation(space='world'), space='world')
distBetweenCtrls = (ctrl.getTranslation(space='world') -
upCtrl.getTranslation(space='world')).length()
if distBetweenCtrls < 8.0:
upCtrl.s.set([distBetweenCtrls / 8.0] * 3)
ctrl.s.set([distBetweenCtrls / 8.0] * 3)
select(ctrl)
def cardIk(card):
#ctrl = mel.eval( 'curve -d 1 -p -0.5 1 -0.866026 -p -0.5 1 0.866025 -p 1 1 0 -p -0.5 1 -0.866026 -p 0 0 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 0 0 0 -p -0.5 1 0.866025 -p 1 1 0 -p 0 0 0 -p 1 -1 0 -p -0.5 -1 -0.866026 -p -0.5 -1 0.866025 -p 1 -1 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 ;' )
ctrl = PyNode(
mel.eval(
'curve -d 1 -p 0 4 0 -p -2.828427 2.828427 -2.47269e-007 -p -4 0 -3.49691e-007 -p -2.828427 -2.828427 -2.47269e-007 -p 0 -4 0 -p 2.828427 -2.828427 0 -p 4 0 0 -p 2.828427 2.828427 0 -p 0 4 0 -p -1.23634e-007 2.828427 2.828427 -p -1.74846e-007 0 4 -p -1.23634e-007 -2.828427 2.828427 -p 0 -4 0 -p 3.70903e-007 -2.828427 -2.828427 -p 5.24537e-007 0 -4 -p 3.70903e-007 2.828427 -2.828427 -p 0 4 0 -p 0 0 0 -p 0 -4 0 -p 0 0 0 -p -4 0 0 -p 4 0 0 -p 0 0 -4 -p 0 0 4 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 ;'
))
ctrl.rename(card.name() + "_target")
upCtrl = duplicate(ctrl)[0]
upCtrl.rename(card.name() + "_up")
aim = spaceLocator()
aim.setParent(ctrl)
aim.t.set(0, 0, 0)
hide(aim)
up = spaceLocator()
up.setParent(upCtrl)
hide(up)
base = spaceLocator()
base.rename('cardIkBase')
hide(base)
pointConstraint(card, base)
util.moveTo(ctrl, card.joints[-1])
util.moveTo(upCtrl, card.vtx[1])
aimConstraint(aim,
card,
wut='object',
wuo=up,
aim=[0, -1, 0],
u=[0, 0, -1])
dist = distanceDimension(base, aim)
dist.getParent().setParent(ctrl)
hide(dist)
core.math.divide(dist.distance,
dist.distance.get() / card.sy.get()) >> card.sy
follower = spaceLocator()
follower.rename('cardIkFollower')
follower.setParent(card)
follower.t.set(0, 0, 0)
hide(follower)
pointConstraint(up, follower, skip=['x', 'z'])
sideDist = distanceDimension(follower, up)
sideDist.getParent().setParent(ctrl)
hide(sideDist)
core.math.divide(sideDist.distance,
sideDist.distance.get() / card.sz.get()) >> card.sz
# Orient controls with the card so moving in local space initially preserves orientation.
upCtrl.setRotation(card.getRotation(space='world'), space='world')
ctrl.setRotation(card.getRotation(space='world'), space='world')
distBetweenCtrls = (ctrl.getTranslation(space='world') -
upCtrl.getTranslation(space='world')).length()
if distBetweenCtrls < 8.0:
upCtrl.s.set([distBetweenCtrls / 8.0] * 3)
ctrl.s.set([distBetweenCtrls / 8.0] * 3)
select(ctrl)
