def create_fk_setup(self):
"""Creates the FK setup."""
cmds.orientConstraint(self.controls['fan'], self.result_jnts[0], mo=True)
mdl = cmds.shadingNode('multDoubleLinear', asUtility=True)
mdl = cmds.rename(mdl, '%s_%s_MDL' % (self.side, self.modulename))
if self.side == 'R':
cmds.expression(s='%s.input1 = time * (-1);' % mdl, o=mdl, ae=1, uc='all')
else:
cmds.expression(s='%s.input1 = time;' % mdl, o=mdl, ae=1, uc='all')
# END if
cmds.connectAttr('%s.speed' % self.controls['fan'], '%s.input2' % mdl, f=True)
cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=0, v=0)
cmds.setDrivenKeyframe('%s.rotate%s' % (self.controls['offset'], self._up_axis), cd='%s.output' % mdl, dv=1, v=1)
cmds.keyTangent('%s_rotate%s' % (self.controls['offset'], self._up_axis), itt='linear', ott='linear', f=(0, 1))
cmds.selectKey('%s_rotate%s' % (self.controls['offset'], self._up_axis), add=True, k=True, f=(0, 1))
cmds.setInfinity(pri='cycleRelative', poi='cycleRelative')
def mirrorDrivenkeys(src, dst):
for driver, driven in getDrivenKeys(src):
newDriver = driver.replace(src, dst)
newDriven = driven.replace("L_", "R_")
if not mc.objExists(newDriven) or newDriven == driven:
newDriven = driven.replace("left", "right")
if not mc.objExists(newDriven) or newDriven == driven:
newDriven = driven.replace("L", "R")
if not mc.objExists(newDriver) or not mc.objExists(newDriven):
continue
if newDriven == driven:
continue
driverValues = mc.keyframe(driven, q=True, fc=True)
drivenValues = mc.keyframe(driven, q=True, vc=True)
for drv, dnv in zip(driverValues, drivenValues):
if re.search(
"(translateX|eyeRotInner_ctl_0.rotateZ|mouthCorner_ctl_0\.translateY|mouth_ctl_0\.translateY)$",
newDriver,
):
dnv = dnv * -1
if re.search("(mainCheek_ctl_0\.translateX)$", newDriver):
dnv = dnv * -1
mc.setDrivenKeyframe(newDriven, cd=newDriver, dv=drv, v=dnv)
print "Copy Driven keys: %s : %s -> %s : %s" % (driver, driven, newDriver, newDriven)
def resetFn(self, wid):
print 'resetting', wid
try:
cmds.undoInfo(openChunk=True)
#get original pose from driven dict
initialPoseDict = json.loads(cmds.getAttr(self.currentFace.blendBoard + '.initialPoseDict'))
initialPoseAttrs = initialPoseDict[wid.pose]
#store current slider/attr val
preVal = cmds.getAttr(wid.pose)
#iterate over the attrs and set them bvack to original
#TODO: rotate order?
cmds.setAttr(wid.pose, 1.0)
for att in wid.driven:
#print att, initialPoseAttrs[att]
cmds.setAttr(att, initialPoseAttrs[att])
#set the old driven keyframe
cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)
#reset the slider/attr val
cmds.setAttr(wid.pose, preVal)
self.checkForEditedPoses()
except Exception, err:
import traceback
print(traceback.format_exc())
def setDrivenKey(driverInfo, drivenInfo):
"""Automate the set driven key through the use of set driven key
@param driverInfo list of values of the driver attribute. The key should be the target attribute
@param drivenInfo list of values of the driven attribute. The key should be the target attribute
@code
import libUtilities
#Set up the driver info
driverInfo = {"ctrl.tx":[0,1]}
drivenInfo = {"cube.rz":[0,360]}
libUtilities.setDrivenKey(driverInfo, drivenInfo )
@endcode
@warning The number of values in both driver and driven attribute should be same
"""
if type(driverInfo) != dict or type(drivenInfo) != dict:
raise Exception("Not a dictInfo")
driver = driverInfo.keys()[0]
driven = drivenInfo.keys()[0]
currentDriverValue = cmds.getAttr(driver)
currentDrivenValue = cmds.getAttr(driven)
cmds.setDrivenKeyframe(driven, itt="linear", ott="linear", cd=driver)
for driveAttr, drivenAttr in zip(driverInfo[driver], drivenInfo[driven]):
cmds.setAttr(driver, driveAttr)
cmds.setAttr(driven, drivenAttr)
cmds.setDrivenKeyframe(driven, itt="linear", ott="linear", cd=driver)
cmds.setAttr(driver, currentDriverValue)
cmds.setAttr(driven, currentDrivenValue)
def on_btn_setDrivenkey_clicked(self, args=None):
if args==None:return
rdnDict = {'rdn_A':'ypxn', # -X+Y
'rdn_B':'y', # +Y
'rdn_C':'ypxp', # +X+Y
'rdn_D':'x', # -X
'rdn_E':'x', # +X
'rdn_F':'ynxn', # -X-Y
'rdn_G':'y', # -Y
'rdn_H':'ynxp' # +X-Y
}
selectRdn = ''
for child in self.rdn_Box.findChildren(QtGui.QRadioButton):
if child.isChecked():
selectRdn = str(child.objectName())
break
else:
continue
#-----------------------------------------------------------
driverAttr = '%s.%s'%(self.__model.data(self.listView.selectedIndexes()[0], QtCore.Qt.DisplayRole), rdnDict.get(selectRdn))
drivenAttr = str(self.lineEdit.text())
driverValue = mc.getAttr(driverAttr)
drivenValue = mc.getAttr(drivenAttr)
mc.setDrivenKeyframe(drivenAttr, cd=driverAttr, dv=driverValue, v=drivenValue)
print driverAttr, drivenAttr, driverValue, drivenValue
def stampSDK( *args ):
global drivenAttrs
drivenAttrs = cmds.ls(sl=True)
# Stamp SDK
for sel in drivenAttrs:
cmds.setDrivenKeyframe( "%s.%s" %(sel, cmds.channelBox( "mainChannelBox", q=True, sma=True )[0]),
cd=driverAttr)
def updateFn(self, wid):
#check that the pose is fully on
if wid.poseSlider.value() != 100:
cmds.warning('Pose slider is not fully on, must be 1.0 in able to save edit.')
return False
cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)
self.checkForEditedPoses()
def on_actionQuickSDK_triggered(self, clicked=None):
if clicked==None:return
DriverAttribute = str(self.driverAttributelineEdit.text())
for i in range(self.drivenAttributelineEdit.count()):
Drivenattr = str(self.drivenAttributelineEdit.item(i).text())
mc.setDrivenKeyframe(Drivenattr, cd=DriverAttribute)
def dpSetHandFollowSDK(self, *args):
""" Create the setDrivenKey.
"""
armWristIkCtrl = args[0]
cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.spineChestACtrl+"W0", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.globalCtrl+"W1", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.rootCtrl+"W2", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.spineHipsBCtrl+"W3", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
cmds.setDrivenKeyframe(armWristIkCtrl+"_Orient_Grp_ParentConstraint."+self.headCtrl+"W4", currentDriver=armWristIkCtrl+"."+self.langDic[self.langName]['c_Follow'])
def getDrivenKeyInfo(obj):
DrivenInfo = []
attributes = mc.setDrivenKeyframe(obj, q=True, dn=True)
if re.match('^No driven attributes', attributes[0]):
return DrivenInfo
for attr in attributes:
DrivenInfo.append((mc.setDrivenKeyframe(attr, q=True, dr=True), attr))
return DrivenInfo
def _setKeyFrame(self, DriverValueSpinbox, DrivenValueSpinbox):
DriverAttibute = str(self.DriverAttributeLineEdit.text())
DrivenAttibute = str(self.DrivenAttributeLineEdit.text())
DriverValue = DriverValueSpinbox.value()
DrivenValue = DrivenValueSpinbox.value()
if len(DriverAttibute) == 0:return
if len(DrivenAttibute) == 0:return
mc.setDrivenKeyframe(DrivenAttibute, cd=DriverAttibute, dv=DriverValue, v=DrivenValue)
def setMultipleSDKs(driven, attr, drivenValus, driver, driverValues=DRIVER_VALUES):
if(len(drivenValus) != len(driverValues)):
print("Driver and driven value's length mismatch. ")
return
else:
zippedDriverDrivenValus = zip(driverValues, drivenValus)
for i in zippedDriverDrivenValus:
cmds.setDrivenKeyframe(driven + "." + attr,
currentDriver=driver,
driverValue=i[0],
value=i[1]
)
def createCoordinatesSwitch(driversList=[], attrsList=[], drivenNode="", spaceNode="", side="left", constraintType="parent"):
"""
Arguments:
driversList: list of driver nodes
attrsList : list of nice names for the enum attribute
driven node: the name of the node that wil receive the attribute for the switch
spaceNode: the node that will receive the constraint itself. MOst f the time is "_CON" node and
it ususally is a parent of the "drivenNode"
"""
worldCon = checkForWorldControl()
#check if we have more than 1 objects with the same same
drivenNodes = cmds.ls(drivenNode)
if len(drivenNodes) == 1:
#create a group node to store the created nodes
grpNode = cmds.createNode("transform", n=drivenNode+"_SpaceSwitching_GRP")
#create switching attribute
cmds.addAttr(drivenNode, longName="parent", at="enum", en=":".join(attrsList))
cmds.setAttr(drivenNode+".parent", k=1)
driverConNodes = []
for driver in driversList:
#create 1 node per space that is aligned to the drivenNode, but parent Constrained to the driver space
spaceControlNodes = createControl(side, drivenNode+"_"+driver, "null" , sdk=0, con=1)
control = spaceControlNodes[-1]
sCON = spaceControlNodes[1]
sPOS = spaceControlNodes[0]
cmds.delete(control)
alignNodes(sPOS, [spaceNode])
cmds.parent(sPOS, grpNode)
cmds.parentConstraint(driver, sCON, mo=1, st="none", sr="none")
driverConNodes.append(sCON)
mainConstraint = ""
if constraintType == "parent":
mainConstraint = cmds.parentConstraint(driverConNodes, spaceNode, mo=0, st="none", sr="none")[0]
if constraintType == "orient":
mainConstraint = cmds.orientConstraint(driverConNodes, spaceNode, mo=0, skip="none")[0]
c=0
for driver in driverConNodes:
i=0
for dr in driversList:
if c==i:
cmds.setDrivenKeyframe(mainConstraint, at=driver+"W"+str(i), currentDriver=drivenNode+".parent", driverValue=i, value=1)
else:
cmds.setDrivenKeyframe(mainConstraint, at=driver+"W"+str(c), currentDriver=drivenNode+".parent", driverValue=i, value=0)
i=i+1
c=c+1
def fkControllerCreator(fkSize, legOrArm):
orientController = cmds.optionMenu("UI_orientControllerMenu", q=1, v=1)
# Create controllers and group offsets
# Change rotation, color
for y in range(chainLen):
anim_group = cmds.group(em=1, n=ogChain[y] + "_fk_anim_grp")
fk_controller = cmds.circle(n=ogChain[y] + "_fk_anim")[0] # If not [0] it'll warn some stuff related to Maya underworld
# Set scale
cmds.scale(fkSize, fkSize, fkSize, fk_controller)
cmds.matchTransform(anim_group, ogChain[y])
cmds.delete(cmds.parentConstraint(ogChain[y], fk_controller))
cmds.parent(fk_controller, anim_group)
# Set controller orientation based on second axis
if orientController == "x": cmds.rotate(90,0,0, fk_controller)
if orientController == "y": cmds.rotate(0,90,0, fk_controller)
if orientController == "z": cmds.rotate(0,0,90, fk_controller)
# Freeze transform, delete history and set color
cmds.makeIdentity(fk_controller, a = 1, t = 1, r = 1, s = 0)
cmds.delete(fk_controller, ch = 1)
cmds.color(fk_controller, rgb=controllerColor)
# Set SDK visibility
sdkDriver = switcherLoc[0] + ".FKIK_Mode"
cmds.setAttr(sdkDriver, 1)
cmds.setDrivenKeyframe(ogChain[0] + "_fk_anim_grp.visibility", cd=sdkDriver, v=1, dv=0)
cmds.setAttr(sdkDriver, 0)
cmds.setDrivenKeyframe(ogChain[0] + "_fk_anim_grp.visibility", cd=sdkDriver, v=0, dv=1)
# Lock .t and .s attributes
#for x in ["X", "Y", "Z"]:
#cmds.setAttr(fk_controller + ".translate" + x, k=0, l=1)
#cmds.setAttr(fk_controller + ".scale" + x, k=0, l=1)
# Create ordered hierarchy
for x in reversed(range(chainLen)):
if x == 0:
continue
cmds.parent(ogChain[x] + "_fk_anim_grp", ogChain[x-1] + "_fk_anim")
# Set orientConstraint _anim controllers with _fk hierarchy
for x in range(chainLen):
cmds.parentConstraint(ogChain[x] + "_fk_anim", ogChain[x] + "_fk")
# If leg chain is selected delete toe controller, else not
if legOrArm == "Leg":
if x == (chainLen-1):
cmds.delete(ogChain[chainLen-1] + "_fk_anim_grp")
def space_switch(self, spaces, aliases=None):
"""
Add space switches to this control object
:param list spaces: A list of spaces
"""
# Arg check
assert isinstance(spaces, list), "Pass spaces as a list"
err = "One or more passed spaces does not exist."
assert all(cmds.objExists(o) for o in spaces), err
spaces = [MayaBaseNode(n) for n in spaces]
parent_con = MayaBaseNode(cmds.parentConstraint(spaces, self.null, maintainOffset=True)[0])
# Figure out how the attribute of weights looks like
# add SPACES display attr in control
if not aliases:
prefixes = [n.nice_name.split(self.delimiter)[0] for n in spaces]
enum_names = [n.nice_name.lstrip(prefix) for prefix, n in zip(prefixes, spaces)]
else:
enum_names = aliases
# Attr names refers to the attributes on the parent constraint
attr_names = [s.nice_name + 'W' + str(i) for i,s in enumerate(spaces)]
# This dictionary maps space's short names to the parent constraint attributes
attr_dict = {k.short_name:v for k,v in zip(spaces, attr_names)}
# Add attributes in this control for spaces
self.add_attr('SPACE', at='enum', enumName='-' * 10, h=False, k=True)
self.add_attr('spaces', at='enum', enumName=':'.join(enum_names), h=False, k=True)
# Lock displayable space enum
cmds.setAttr(self.plug('SPACE'), lock=True)
spaces_set = set(spaces)
# Connect spaces through set driven keys
for enum_name, space in zip(enum_names, spaces):
cmds.setAttr(self.plug('spaces'), enum_names.index(enum_name))
for other_space in spaces_set.difference([space]):
parent_con.set_attr(attr_dict[other_space.short_name], 0)
attr = attr_dict[other_space.short_name]
cmds.setDrivenKeyframe(parent_con.plug(attr), cd=self.plug('spaces'))
attr = attr_dict[space.short_name]
parent_con.set_attr(attr_dict[space.short_name], 1)
cmds.setDrivenKeyframe(parent_con.plug(attr), cd=self.plug('spaces'))
def _setKeyFrame(self, DriverValueSpinbox, DrivenValueSpinbox):
DriverAttibute = str(self.DriverAttributeLineEdit.text())
DrivenAttibute = str(self.DrivenAttributeLineEdit.text())
DriverValue = DriverValueSpinbox.value()
DrivenValue = DrivenValueSpinbox.value()
if len(DriverAttibute) == 0: return
if len(DrivenAttibute) == 0: return
mc.setDrivenKeyframe(DrivenAttibute,
cd=DriverAttibute,
dv=DriverValue,
v=DrivenValue)
def _dynamic_settings(self, dyCtrl, hairSys, fol):
"""
Responsible for setting the dynamic control attributes.
"""
# header
cmds.addAttr(dyCtrl, ln="dynamic", at="enum",
en="settings:", k=True)
cmds.setAttr("{0}.dynamic".format(dyCtrl), l=True)
# EN
cmds.addAttr(dyCtrl, ln="EN", at="enum", en="on:off", k=True)
# off
cmds.setAttr("{0}.EN".format(dyCtrl), 1)
cmds.setAttr("{0}Shape.simulationMethod".format(hairSys), 0)
cmds.setDrivenKeyframe("{0}Shape.simulationMethod".format(hairSys),
"{0}.EN".format(dyCtrl))
# on
cmds.setAttr("{0}.EN".format(dyCtrl), 0)
cmds.setAttr("{0}Shape.simulationMethod".format(hairSys), 3)
cmds.setDrivenKeyframe("{0}Shape.simulationMethod".format(hairSys),
"{0}.EN".format(dyCtrl))
# motion drag
cmds.addAttr(dyCtrl, ln="motionDrag", at="float", k=1, hnv=1, hxv=1)
cmds.connectAttr("{0}.motionDrag".format(dyCtrl),
"{0}Shape.motionDrag".format(hairSys), f=1)
# drag
cmds.addAttr(dyCtrl, ln="drag", at="float",
k=1, hnv=1, hxv=1)
cmds.connectAttr("{0}.drag".format(dyCtrl),
"{0}Shape.drag".format(hairSys), f=1)
# damp
cmds.addAttr(dyCtrl, ln="damp", at="float",
dv=0, k=1, hnv=1, hxv=1)
cmds.connectAttr("{0}.damp".format(dyCtrl),
"{0}Shape.damp".format(hairSys), f=1)
# iterations
cmds.addAttr(dyCtrl, ln="iterations", at="float", k=1, hnv=1, hxv=1)
cmds.connectAttr("{0}.iterations".format(dyCtrl),
"{0}Shape.iterations".format(hairSys), f=1)
# stiffness
cmds.addAttr(dyCtrl, ln="stiffness", at="float", k=0, hnv=1, hxv=1,
dv=1, min=0, max=1)
cmds.connectAttr("{0}.stiffness".format(dyCtrl),
"{0}Shape.stiffness".format(hairSys), f=1)
def visibilityDrivenKeys( _blendA, _blendB, _blendACtls, _blendBCtls, _attrCurve, _attrSize, *args):
attrName = _blendA + '_' + _blendB + '_blend'
blendAttr = _attrCurve + '.' + attrName
blendRangeStart = 0
blendRangeEnd = int(_attrSize)
cmds.setAttr( blendAttr, blendRangeStart)
for x in _blendBCtls:
visibilityAttr = x + '.visibility'
cmds.setAttr( visibilityAttr, 0)
cmds.setDrivenKeyframe(visibilityAttr, cd=blendAttr, value=0, driverValue=blendRangeStart)
for x in _blendACtls:
visibilityAttr = x + '.visibility'
cmds.setAttr( visibilityAttr, 1)
cmds.setDrivenKeyframe(visibilityAttr, cd=blendAttr, value=1, driverValue=blendRangeStart)
cmds.setAttr( blendAttr, blendRangeEnd)
for x in _blendACtls:
visibilityAttr = x + '.visibility'
cmds.setAttr( visibilityAttr, 0)
cmds.setDrivenKeyframe(visibilityAttr, cd=blendAttr, value=0, driverValue=blendRangeEnd)
for x in _blendBCtls:
visibilityAttr = x + '.visibility'
cmds.setAttr( visibilityAttr, 1)
cmds.setDrivenKeyframe(visibilityAttr, cd=blendAttr, value=1, driverValue=blendRangeEnd)
def RKConstraintSetDrivenKey(self, xformCtrl, attrNum):
sels = cmds.ls(selection = 1)
for var in range(0, len(sels)):
constraint = sels[var]
#get attributes
FKAttr = cmds.listAttr(constraint, userDefined = 1) [1]
IKAttr = cmds.listAttr(constraint, userDefined = 1) [0]
ctrlAttr = cmds.listAttr(xformCtrl, userDefined = 1) [attrNum - 1]
#set attributes to FK
cmds.setAttr((xformCtrl + "." + ctrlAttr), 1)
cmds.setAttr((constraint + "." + FKAttr), 1)
cmds.setAttr((constraint + "." + IKAttr), 0)
#key attributes
cmds.setDrivenKeyframe((constraint + "." + FKAttr), cd = (xformCtrl + "." + ctrlAttr))
cmds.setDrivenKeyframe((constraint + "." + IKAttr), cd = (xformCtrl + "." + ctrlAttr))
#set attributes to IK
cmds.setAttr((xformCtrl + "." + ctrlAttr), 0)
cmds.setAttr((constraint + "." + FKAttr), 0)
cmds.setAttr((constraint + "." + IKAttr), 1)
#key attributes
cmds.setDrivenKeyframe((constraint + "." + FKAttr), cd = (xformCtrl + "." + ctrlAttr))
cmds.setDrivenKeyframe((constraint + "." + IKAttr), cd = (xformCtrl + "." + ctrlAttr))
cmds.setAttr((xformCtrl + "." + ctrlAttr), 0)
def on_actionMirrorSDK_triggered(self, clicked=None):
if clicked == None:return
ReverDt = {'X':1, 'Y':1, 'Z':1}
if self.REVERX.isChecked():ReverDt['X'] = -1
if self.REVERY.isChecked():ReverDt['Y'] = -1
if self.REVERZ.isChecked():ReverDt['Z'] = -1
for i,DrivenInformations in enumerate(self.targentAtrLst):
DrivenAttr = str(list(self.Model.stringList())[i])
for driverValue, value in zip(DrivenInformations[2], DrivenInformations[3]):
mc.setDrivenKeyframe(DrivenAttr, cd=DrivenInformations[0], dv=driverValue, v=value * ReverDt.get(DrivenInformations[0][-1], 1))
print DrivenInformations[0], DrivenAttr
def RKCtrlSetDrivenKey(self, xformCtrl, attrNum, controlType):
sels = cmds.ls(selection = 1)
for var in range(0, len(sels)):
ctrl = sels[var]
xformCtrlAttr = ctrlAttr = cmds.listAttr(xformCtrl, userDefined = 1) [attrNum - 1]
if controlType is "FK":
cmds.setAttr((xformCtrl + "." + xformCtrlAttr), 0)
cmds.setAttr((ctrl + ".visibility"), 1)
cmds.setDrivenKeyframe((ctrl + ".visibility"), cd = (xformCtrl + "." + xformCtrlAttr))
cmds.setAttr((xformCtrl + "." + xformCtrlAttr), 1)
cmds.setAttr((ctrl + ".visibility"), 0)
cmds.setDrivenKeyframe((ctrl + ".visibility"), cd = (xformCtrl + "." + xformCtrlAttr))
else:
cmds.setAttr((xformCtrl + "." + xformCtrlAttr), 0)
cmds.setAttr((ctrl + ".visibility"), 0)
cmds.setDrivenKeyframe((ctrl + ".visibility"), cd = (xformCtrl + "." + xformCtrlAttr))
cmds.setAttr((xformCtrl + "." + xformCtrlAttr), 1)
cmds.setAttr((ctrl + ".visibility"), 1)
cmds.setDrivenKeyframe((ctrl + ".visibility"), cd = (xformCtrl + "." + xformCtrlAttr))
def create_ik_arm_stretch(self):
"""Creates the IK stretch setup."""
arm_dist, start_loc, end_loc = self.c.distance_node(self.guides['upperArm'], self.guides['hand'])
arm_dist = cmds.rename(arm_dist, '%s_%s_%s' % (self.side, 'arm', self.nc.distance))
start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'armLengthStart', self.nc.locator))
end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'armLengthEnd', self.nc.locator))
cmds.parent(end_loc, self.controls['handik'])
cmds.parent(arm_dist, self.top_grp)
driver = '%sShape.distance' % arm_dist
if self.side == 'R':
mult = cmds.shadingNode('multiplyDivide', asUtility=True)
mult = cmds.rename(mult, '%s_%s_stretch_negative_MDN' % (self.side, 'arm'))
cmds.connectAttr('%sShape.distance' % arm_dist, '%s.input1X' % mult, f=True)
cmds.setAttr('%s.input2X' % mult, -1)
driver = '%s.outputX' % mult
# END if
upper_arm_len = cmds.getAttr('%s.tx' % self.ik_jnts[1])
fore_arm_len = cmds.getAttr('%s.tx' % self.ik_jnts[2])
sum_len = upper_arm_len + fore_arm_len
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
dv=sum_len, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
dv=sum_len*2, v=upper_arm_len*2, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
dv=sum_len, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
dv=sum_len*2, v=fore_arm_len*2, itt='linear', ott='linear')
cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[1], 1)
cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[2], 1)
# stretch the result joints
curve = '%s_%s_%s' % (self.side, 'upperArm', self.nc.curve)
self.stretch_result_joints(curve, 'upperArm', self.upper_arm_jnts)
curve = '%s_%s_%s' % (self.side, 'foreArm', self.nc.curve)
self.stretch_result_joints(curve, 'foreArm', self.fore_arm_jnts)
def constraintFunc(scaleController, selectChain):
# Create some blendColors node with the same name of the joint
for x in range(chainLen):
# Setup orient constraints
cmds.parentConstraint((ogChain[x] + "_ik"), ogChain[x])
cmds.parentConstraint((ogChain[x] + "_fk"), ogChain[x])
# Setup SDK naming convention
sdkDriver = switcherLoc[0] + ".FKIK_Mode"
ikSdkDriven = ogChain[x] + "_parentConstraint1." + ogChain[x] + "_ikW0"
fkSdkDriven = ogChain[x] + "_parentConstraint1." + ogChain[x] + "_fkW1"
# Setup SDK
cmds.setAttr(sdkDriver, 0)
cmds.setDrivenKeyframe(ikSdkDriven, cd=sdkDriver, v=0, dv=0)
cmds.setDrivenKeyframe(fkSdkDriven, cd=sdkDriver, v=1, dv=0)
cmds.setAttr(sdkDriver, 1)
cmds.setDrivenKeyframe(ikSdkDriven, cd=sdkDriver, v=1, dv=1)
cmds.setDrivenKeyframe(fkSdkDriven, cd=sdkDriver, v=0, dv=1)
ikChainBuild(scaleController, selectChain)
fkControllerCreator(scaleController, selectChain)
def create_ik_stretch(self):
"""Creates the IK stretch setup."""
arm_dist, start_loc, end_loc = self.c.distance_node(self.guides['thigh'], self.guides['foot'])
arm_dist = cmds.rename(arm_dist, '%s_%s_%s' % (self.side, 'leg', self.nc.distance))
start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'legLengthStart', self.nc.locator))
end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'legLengthEnd', self.nc.locator))
cmds.parent(end_loc, self.controls['ik'])
cmds.parent(arm_dist, self.top_grp)
driver = '%sShape.distance' % arm_dist
if self.side == 'R':
mult = cmds.shadingNode('multiplyDivide', asUtility=True)
mult = cmds.rename(mult, '%s_%s_stretch_negative_MDN' % (self.side, 'leg'))
cmds.connectAttr('%sShape.distance' % arm_dist, '%s.input1X' % mult, f=True)
cmds.setAttr('%s.input2X' % mult, -1)
driver = '%s.outputX' % mult
# END if
thigh_len = cmds.getAttr('%s.tx' % self.ik_jnts[1])
shin_len = cmds.getAttr('%s.tx' % self.ik_jnts[2])
sum_len = thigh_len + shin_len
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
dv=sum_len, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[1], cd=driver,
dv=sum_len*2, v=thigh_len*2, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
dv=sum_len, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.ik_jnts[2], cd=driver,
dv=sum_len*2, v=shin_len*2, itt='linear', ott='linear')
cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[1], 1)
cmds.setAttr('%s_translateX.postInfinity' % self.ik_jnts[2], 1)
def ConnectAttributes(self):
temp = 1
for k in range(2):
cmds.setAttr(
self.transformCtrl + "." + self.partition[0] + "_IKFK_Switch",
k)
cmds.setAttr(self.fkCtrlGrp + ".visibility", k)
cmds.setDrivenKeyframe(self.fkCtrlGrp + ".visibility",
cd=self.transformCtrl + "." +
self.partition[0] + "_IKFK_Switch",
itt="linear",
ott="linear")
cmds.setAttr(self.ikCtrlGrp + ".visibility", temp)
cmds.setDrivenKeyframe(self.ikCtrlGrp + ".visibility",
cd=self.transformCtrl + "." +
self.partition[0] + "_IKFK_Switch",
itt="linear",
ott="linear")
for i, t in enumerate(self.constraintList):
cmds.setAttr("%s.w%i" % (cmds.rename(t, t), 0), k)
cmds.setDrivenKeyframe("%s.w%i" % (cmds.rename(t, t), 0),
cd=self.transformCtrl + "." +
self.partition[0] + "_IKFK_Switch",
itt="linear",
ott="linear")
cmds.setAttr("%s.w%i" % (cmds.rename(t, t), 1), temp)
cmds.setDrivenKeyframe("%s.w%i" % (cmds.rename(t, t), 1),
cd=self.transformCtrl + "." +
self.partition[0] + "_IKFK_Switch",
itt="linear",
ott="linear")
temp = 0
def readSetDrivenKeyDataFromFile(filePath, lock=False):
'''
Reads and reconstructs setDrivenKeyfraomes from json file exported from writeSetDrivenKeyDataToFile()
sdkFile = 'Z:/users/tcoleman/code/temp_sdk_data.json'
readSetDrivenKeyDataFromFile(sdkFile)
'''
fh = open(filePath, 'r')
sdkDataDict = json.load(fh)
fh.close()
# iterate through dict keys
for sdkCurve, sdkDict in sdkDataDict.iteritems():
driver = sdkDict['driver']
driven = sdkDict['driven']
driverKeys = sdkDict['driverKeys']
drivenKeys = sdkDict['drivenKeys']
itt = sdkDict['itt']
ott = sdkDict['ott']
pri = sdkDict['pri']
poi = sdkDict['poi']
if mc.objExists(driver) and mc.objExists(driven):
i = 0
for driverKey, drivenKey in zip(driverKeys, drivenKeys):
# Create setDrivenKeyframes
mc.setDrivenKeyframe(driven, cd=driver, dv=driverKey, value=drivenKey)
LOG.debug('SetDrivenKeyframe: Driver=%s.%s, Driven=%s.%s' % (driver, driven, driverKey, drivenKey))
# Set keyframe tangents
mc.selectKey(sdkCurve, add=True, k=True, f=(driverKey, driverKey))
mc.keyTangent(itt=itt[i], ott=ott[i])
i = i + 1
# Set pre/post infinity
mc.selectKey(sdkCurve, add=True, k=True, f=(driverKeys[0], driverKeys[0]))
mc.setInfinity(pri=pri)
mc.selectKey(clear=True)
mc.selectKey(sdkCurve, add=True, k=True, f=(driverKeys[-1], driverKeys[-1]))
mc.setInfinity(poi=poi)
# Lock setDrivenKeyframes if specified
if lock:
mc.setAttr('%s.keyTimeValue' % sdkCurve, lock=True)
mc.refresh()
LOG.info('SetDrivenKeyframe Data read from %s' % filePath)
def legIK(ikFootScale, legikHandle, pvName):
ballikHandle = cmds.ikHandle(sj=ogChain[2] + "_ik", ee=ogChain[3] + "_ik", sol="ikSCsolver", n=side + "ball_ikHandle")
toeikHandle = cmds.ikHandle(sj=ogChain[3] + "_ik", ee=ogChain[4] + "_ik", sol="ikSCsolver", n=side + "toe_ikHandle")
# Create and place ik controller
ikFootControl = cmds.curve(d=2, p=[(0.997, 0, 1.789), (0, 0, 2.39), (-0.997,0,1.789), (-1.108, 0, 0), (-0.784, 0,-2.5),
(0, 0,-3), (0.784, 0, -2.5), (1.108, 0, 0), (0.997, 0, 1.789), (0, 0, 2.39)],
k=[0,1,2,3,4,5,6,7,8,9,10], n=side + "leg_anim_ik")
# Rename shape node
shapeList = cmds.listRelatives(ikFootControl, s = True)
cmds.rename(shapeList, ikFootControl + "Shape")
ikFootControlGrp = cmds.group(em=1, n=ikFootControl + "_grp")
cmds.parent(ikFootControl, ikFootControlGrp)
# Set size, freeze transform, create offset group and color
cmds.scale(ikFootScale, ikFootScale, ikFootScale, ikFootControlGrp)
cmds.move(0,-3.2,0, ikFootControl, r=1)
cmds.makeIdentity(ikFootControl, a = 1, t = 1, r = 1, s = 1)
cmds.delete(ikFootControl, ch = 1)
cmds.delete(cmds.pointConstraint(ogChain[3] + "_ik", ikFootControlGrp))
cmds.color(ikFootControl, rgb=controllerColor)
# pivot snapping on ankle joint
piv = cmds.xform(ogChain[2], q=True, ws=True, t=True)
cmds.xform(ikFootControl, ws=True, piv=piv)
cmds.parent(ballikHandle[0], toeikHandle[0], legikHandle[0], ikFootControl)
#---------- Making Pole Vector -------------#
# Pole Vector controller ---> Sphere
pvController = createSphere(nome= side+pvName+"_PV")
findPoleVector(loc=pvController, targetHandle=legikHandle[0])
cmds.addAttr(pvController, ln="Follow", k=1, r=1, min=0, max=1)
cmds.addAttr(pvController, ln="Follow_Leg_Foot", k=1, r=1, min=0, max=1, dv=0.5)
# Create attributes on ikController
cmds.addAttr(ikFootControl, at="enum",enumName = "------", ln="Attributes", k=1, r=1)
cmds.addAttr(ikFootControl, ln="Twist", k=1, r=1)
cmds.addAttr(ikFootControl, ln="Lateral_Roll", k=1, r=1)
for bone in ["Ankle", "Ball", "Toe_Tap"]:
cmds.addAttr(ikFootControl, at="enum", enumName = "------", ln=bone, k=1, r=1)
for coord in ["X", "Y", "Z"]:
cmds.addAttr(ikFootControl, ln=bone+coord, k=1, r=1)
# Parent ikController and PV under _rig_GRP
cmds.parent(ikFootControlGrp, pvController + "_grp" ,rigGrp)
# Set SDK visibility
sdkDriver = switcherLoc[0] + ".FKIK_Mode"
cmds.setAttr(sdkDriver, 0)
cmds.setDrivenKeyframe(ikFootControlGrp + ".visibility", cd=sdkDriver, v=0, dv=0)
cmds.setDrivenKeyframe(pvController + "_grp.visibility", cd=sdkDriver, v=0, dv=0)
cmds.setAttr(sdkDriver, 1)
cmds.setDrivenKeyframe(ikFootControlGrp + ".visibility", cd=sdkDriver, v=1, dv=1)
cmds.setDrivenKeyframe(pvController + "_grp.visibility", cd=sdkDriver, v=1, dv=1)
def edo_convertBlendShapeDrivingExToSdk(cbs, canim, dirvalue, outvalue):
#cbs mxattr[1]
#value = mxattr[1]
wc = cmds.blendShape(cbs, q=1, wc=1)
for i in range(0, wc):
#i=0
attr = cbs + '.weight[' + str(i) + ']'
nattr = cbs + '.' + cmds.aliasAttr(attr, q=1)
connects = cmds.listConnections(attr, s=1, d=0)
if connects:
connect = connects[0]
if cmds.nodeType(connect) == 'expression' and cbs.replace(
'__BLENDSHAPE', '__EXPRESSION') in connect:
print 'convert expression to setDrivenKey'
drivers = cmds.listConnections(connect + '.input',
s=1,
d=0,
p=1)
if drivers:
driver = drivers[0]
cmds.delete(connect.split('.')[0])
edo_createSetDrivenKey(driver, nattr, dirvalue, outvalue)
else:
ans = cmds.ls(connect, type='animCurve')
if ans:
an = ans[0]
if not an == canim:
continue
drivers = cmds.listConnections(an + '.input',
s=1,
d=0,
p=1)
if drivers:
driver = drivers[0]
print 'add set driven key frame on ... ' + nattr
cmds.setDrivenKeyframe(nattr,
cd=driver,
dv=float(dirvalue),
v=float(outvalue),
itt='linear',
ott='linear')
else:
dvattr = nattr.split('__')[-1].replace('_CONNECT_',
'_FRAME.').replace(
'fourAxis', 'fourAxis_')
print 'check ... ' + dvattr + ' is existed?'
if cmds.objExists(dvattr):
print 'add setNewDrivenKeyFrame...'
edo_createSetDrivenKey(dvattr, nattr, dirvalue, outvalue)
def create_ik_stretch(self):
"""Creates the IK stretch setup."""
shoulder_dist, start_loc, end_loc = self.c.distance_node(self.guides['shoulderBase'], self.guides['shoulderEnd'])
shoulder_dist = cmds.rename(shoulder_dist, '%s_%s_%s' % (self.side, self.modulename, self.nc.distance))
start_loc = cmds.rename(start_loc, '%s_%s_%s' % (self.side, 'shoulderLengthStart', self.nc.locator))
end_loc = cmds.rename(end_loc, '%s_%s_%s' % (self.side, 'shoulderLengthEnd', self.nc.locator))
cmds.parent(end_loc, self.controls['ik'])
cmds.parent(shoulder_dist, start_loc, self.top_grp)
driver = '%sShape.distance' % shoulder_dist
shoulder_len = cmds.getAttr('%s.tx' % self.result_jnts[1])
sum_len = shoulder_len
cmds.setDrivenKeyframe('%s.translateX' % self.result_jnts[1], cd=driver, dv=sum_len, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.result_jnts[1], cd=driver, dv=sum_len*2, v=shoulder_len*2, itt='linear', ott='linear')
cmds.setAttr('%s_translateX.postInfinity' % self.result_jnts[1], 1)
self.stretch_switch('%s_translateX' % self.result_jnts[1], self.result_jnts[1], self.switch_control, 'translateX')
def updateFn(self, wid):
#check that the pose is fully on
if wid.poseSlider.value() != 100:
cmds.warning(
'Pose slider is not fully on, must be 1.0 in able to save edit.'
)
return False
cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)
self.checkForEditedPoses()
def edo_createSetDrivenKey(driver, driven, dirvalue, outvalue):
#driven=nattr
sdkn = driven.replace('.', '_')
cmds.setDrivenKeyframe(driven,
cd=driver,
dv=0.0,
v=0.0,
itt='linear',
ott='linear')
cmds.setDrivenKeyframe(driven,
cd=driver,
dv=dirvalue,
v=outvalue,
itt='linear',
ott='linear')
def create_switch(name, control, ik_jj, fk_jj, result_jj):
if control == None:
ctrl_name = name + 'IKFK_switch_cc'
cmds.circle(nr=(0, 1, 0), c=(0, 0, 0), r=1, n=ctrl_name)
cmds.pointConstraint(fk_jj[2], ctrl_name, mo=False)
cmds.pointConstraint(fk_jj[2], ctrl_name, rm=True)
ikfk_attr = cmds.addAttr(ctrl_name,
longName='IKFK',
attributeType='float',
defaultValue=1,
k=True)
# IK / FK Switch: FK connections with driven keys
index = len(fk_jj)
while index > -1:
index = index - 1
cmds.parentConstraint(ik_jj[index],
fk_jj[index],
result_jj[index],
mo=False)
cmds.setAttr(name + 'IKFK_switch_cc.IKFK', 0)
cmds.setAttr(
result_jj[index] + '_parentConstraint1.' + fk_jj[index] + 'W1', 1)
cmds.setDrivenKeyframe(result_jj[index] + '_parentConstraint1.' +
fk_jj[index] + 'W1',
cd=name + 'IKFK_switch_cc.IKFK')
cmds.setAttr(name + 'IKFK_switch_cc.IKFK', 1)
cmds.setAttr(
result_jj[index] + '_parentConstraint1.' + fk_jj[index] + 'W1', 0)
cmds.setDrivenKeyframe(result_jj[index] + '_parentConstraint1.' +
fk_jj[index] + 'W1',
cd=name + 'IKFK_switch_cc.IKFK')
cmds.setAttr(name + 'IKFK_switch_cc.IKFK', 1)
cmds.setAttr(
result_jj[index] + '_parentConstraint1.' + ik_jj[index] + 'W0', 1)
cmds.setDrivenKeyframe(result_jj[index] + '_parentConstraint1.' +
ik_jj[index] + 'W0',
cd=name + 'IKFK_switch_cc.IKFK')
cmds.setAttr(
result_jj[index] + '_parentConstraint1.' + ik_jj[index] + 'W0', 0)
cmds.setAttr(name + 'IKFK_switch_cc.IKFK', 0)
cmds.setDrivenKeyframe(result_jj[index] + '_parentConstraint1.' +
ik_jj[index] + 'W0',
cd=name + 'IKFK_switch_cc.IKFK')
# Control visibility
for fk in fk_jj:
control = fk + '_fk_cc'
condNode = cmds.shadingNode('condition', asUtility=True)
cmds.setAttr(condNode + ".firstTerm", 0)
cmds.setAttr(condNode + ".secondTerm", 1)
cmds.connectAttr(name + 'IKFK_switch_cc.IKFK', condNode + '.firstTerm')
cmds.connectAttr(condNode + '.outColorR', control + '.visibility')
cmds.connectAttr(ctrl_name + '.IKFK', name + '_ik_cc.visibility')
cmds.connectAttr(ctrl_name + '.IKFK', name + '_cc_loc.visibility')
def copySetDrivenKey(sourceDriver,targetDriver,drivenObject,targetObject):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ACKNOWLEDGEMENT:
Jason Schleifer's AFR Materials.
DESCRIPTION:
Copies an SDK
ARGUMENTS:
sourceDriver(string)
targetDriver(string)
drivenObject(string)
targetObject(string)
RETURNS:
driverCurves(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
# Get driven attributes
drivenAttributes = mc.setDrivenKeyframe(drivenObject,q=True, dn=True)
if not drivenAttributes:
guiFactory.warning('No driven attributes found on %s' %drivenObject)
else:
# Get drivers
for attr in drivenAttributes:
print attr
drivers = mc.setDrivenKeyframe(attr,q=True, dr=True)
if not sourceDriver in drivers:
guiFactory.warning('%s not found in the sdk drivers' %sourceDriver)
else:
# Get curve info
curveInfo = returnSetDrivenCurveInfo(sourceDriver,attr)
for key in curveInfo.keys():
attrBuffer = attr.split('.')
# set the SDK's
mc.setDrivenKeyframe(targetObject+'.'+attrBuffer[-1], currentDriver = targetDriver, driverValue = key,value = curveInfo[key])
#Copy Curve tangents and stuff
oldCurve = returnDriverCurve(sourceDriver,attr)
newCurve = returnDriverCurve(targetDriver,attr)
weight = mc.keyTangent(oldCurve[0],q=True, wt=True)
mc.keyTangent(newCurve[0],edit=True,wt=weight[0])
#copy the bits
copyAnimCurveSettingsToCurve(oldCurve[0],newCurve[0])
def copyDrivenKeys(src, dsr, dsn, mirror=1):
for arg in (src, dsr, dsn):
obj, attribute = arg.split('.', 1)
if not mc.objExists(obj):
print 'Error -> obj %s was not Exists...' % obj
return
if not mc.attributeQuery(attribute, n=obj, ex=True):
print 'Error -> attributes %s was not Exists...' % arg
return
mc.delete(mc.keyframe(dsn, q=True, n=True))
driverValues = mc.keyframe(src, q=True, fc=True)
drivenValues = mc.keyframe(src, q=True, vc=True)
for drv, dnv in zip(driverValues, drivenValues):
mc.setDrivenKeyframe(dsn, cd=dsr, dv=drv, v=dnv * mirror)
def copyDrivenKeys(src, dsr, dsn, mirror=1):
for arg in (src, dsr, dsn):
obj, attribute = arg.split('.', 1)
if not mc.objExists(obj):
print 'Error -> obj %s was not Exists...'%obj
return
if not mc.attributeQuery(attribute, n=obj, ex=True):
print 'Error -> attributes %s was not Exists...'%arg
return
mc.delete(mc.keyframe(dsn, q=True, n=True))
driverValues = mc.keyframe(src, q=True, fc=True)
drivenValues = mc.keyframe(src, q=True, vc=True)
for drv, dnv in zip(driverValues, drivenValues):
mc.setDrivenKeyframe(dsn, cd=dsr, dv=drv, v=dnv * mirror)
def setSetDrivenKeyframe(driver='', driverValue=0, driven='', drivenValue=1, setInitialSetDriveKeyframe=False):
'''
Set driven keyframe "wrapper"
setSetDrivenKeyframe( driver='Rt_indexFinger2_jnt.ry', driverValue=90, driven='Rt_indexFinger2_bulge_helper.tz', drivenValue=-.08, setInitialSetDriveKeyframe=True )
'''
if mc.objExists(driver) and mc.objExists(driven):
if setInitialSetDriveKeyframe:
mc.setDrivenKeyframe(driven, cd=driver)
mc.setDrivenKeyframe(driven, cd=driver, value=drivenValue, driverValue=driverValue)
LOG.debug('Set setDrivenKeyframe for %s:%s --> %s:%s' % (driver, driverValue, driven, drivenValue))
else:
LOG.warning('Driver %s or driven %s not found, skipping...' % (driver, driven))
def setSwitchKeys():
for i in weights:
# Sets the value of the currently selected weight attribute to 1
cmds.setDrivenKeyframe(at='w{}'.format(i),
cd='{}.follow'.format(ctrl),
dv=i,
v=1)
# Sets the value of all of the other weight attributes to 0
for n in weights:
if weights[n] == i:
continue
else:
cmds.setDrivenKeyframe(at='w{}'.format(i),
cd='{}.follow'.format(ctrl),
dv=n,
v=0)
def resetFn(self, wid):
print 'resetting', wid
try:
cmds.undoInfo(openChunk=True)
#get original pose from driven dict
initialPoseDict = json.loads(
cmds.getAttr(self.currentFace.blendBoard + '.initialPoseDict'))
initialPoseAttrs = initialPoseDict[wid.pose]
#store current slider/attr val
preVal = cmds.getAttr(wid.pose)
#iterate over the attrs and set them bvack to original
#TODO: rotate order?
cmds.setAttr(wid.pose, 1.0)
for att in wid.driven:
#print att, initialPoseAttrs[att]
cmds.setAttr(att, initialPoseAttrs[att])
#set the old driven keyframe
cmds.setDrivenKeyframe(wid.driven, cd=wid.pose)
#reset the slider/attr val
cmds.setAttr(wid.pose, preVal)
self.checkForEditedPoses()
except Exception, err:
import traceback
print(traceback.format_exc())
def create_fk_setup(self):
"""Creates the FK setup."""
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=1, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[1], cd='%s.length' % self.fk_jnts[0], dv=0, v=0, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=1, itt='linear', ott='linear')
cmds.setDrivenKeyframe('%s.translateX' % self.fk_jnts[2], cd='%s.length' % self.fk_jnts[1], dv=0, v=0, itt='linear', ott='linear')
cmds.selectKey('%s_translateX' % self.fk_jnts[1], k=True, f=(1,))
cmds.setInfinity(poi='cycleRelative')
cmds.selectKey('%s_translateX' % self.fk_jnts[2], k=True, f=(1,))
cmds.setInfinity(poi='cycleRelative')
def createSDK(self,*args):
"""
Create the SDK with given values
"""
#Store user values in variables
driver = mc.textFieldGrp(self.driverField,q=True,text=True)
driverVal = mc.floatField(self.driverValueField,q=True,v=True)
driverAttr = mc.optionMenu(self.driverAttField,q=True,v=True)
drivenValue = mc.floatField(self.drivenValueField,q=True,v=True)
drivenAttr = mc.optionMenu(self.drivenAttField,q=True,v=True)
drivenObj = mc.textFieldGrp(self.drivenField,q=True,text=True)
inTangent = mc.optionMenu(self.inTangentField,q=True,v=True)
outTangent = mc.optionMenu(self.outTangentField,q=True,v=True)
blend = mc.optionMenu(self.insertBlendField,q=True,sl=True)
currentDriver = '%s.%s' % (driver,driverAttr)
mc.setDrivenKeyframe(drivenObj,cd=currentDriver,dv=driverVal,v=drivenValue,at=drivenAttr,itt=inTangent,ott=outTangent,ib=blend)
def makeSdk():
# Getting how many sdk's to create.
sdkNum = int(cmds.optionMenu( 'sdkOpt', q=True, v=True ))
driverField = 'drFltFld'
drivenField = 'dnFltFld'
drivenList = queryAll('drvnTSL')
driver = queryDrvr()
i = 0
while( i < sdkNum ):
# Get my values from the gui
drivenVal = cmds.floatField( drivenField + str(i+1) , q=True, v=True )
driverVal = cmds.floatField( driverField + str(i+1) , q=True, v=True )
for currDriven in drivenList:
cmds.setDrivenKeyframe( currDriven, currentDriver=driver,
driverValue=driverVal, value=drivenVal )
i = i + 1
def set_driven_key(driver_node='',
driver_attr='',
driven_node='',
driven_attr='',
driven_value=None,
driver_value=None,
in_tangent='linear',
out_tangent='linear',
insert_blend=True
):
"""
perform set driven keyframe command.
:param driver_node: <str>
:param driven_node: <str>
:param driver_attr: <str>
:param driven_attr: <str>
:param insert_blend: <bool>
:param in_tangent: <str> get the tangent type: "auto", clamped",
"fast", "flat", "linear", "plateau", "slow", "spline", and "stepnext"
:param out_tangent: <str>
:param driven_value: <float>
:param driver_value: <float>
:return: <bool> True for success. <bool> False for failure.
"""
driver_str = '.'.join([driver_node, driver_attr])
driven_str = '.'.join([driven_node, driven_attr])
if not driven_value:
driven_value = round(cmds.getAttr(driven_str), 3)
if not driver_value:
driver_value = round(cmds.getAttr(driver_str), 3)
# understanding limitations: set driven keyframe does not set the keys well when both the controller
# and the driven object has values.
cmds.setDrivenKeyframe(driven_str, cd=driver_str,
driverValue=driver_value, value=driven_value,
inTangentType=in_tangent, outTangentType=out_tangent,
insertBlend=insert_blend)
# print('cmds.setDrivenKeyframe("{}", cd="{}", driverValue={}, '
# 'value={}, inTangentType="{}", outTangentType="{}", insertBlend={})'.format(
# driven_str, driver_str, driver_value, driven_value, in_tangent, out_tangent, insert_blend))
if __verbosity__:
print("[Set Driven Key] :: {}: {} >> {}: {}".format(driver_str, driver_value, driven_str, driven_value))
return True
def updateSDKWithCurrentObjectInfo (obj, sdkAttribute, driverValues = [0,1]):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
asdf
ARGUMENTS:
jointList(list) - list of joints in order
RETURNS:
newJoints(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>> Get the info
channelKeyList = ('translateX','translateY','translateZ','rotateX','rotateY','rotateZ')
for channel in channelKeyList:
for v in driverValues:
mc.setDrivenKeyframe(obj,attribute = channel, currentDriver = sdkAttribute, driverValue = v)
def on_actionMirrorSDK_triggered(self, clicked=None):
if clicked == None: return
ReverDt = {'X': 1, 'Y': 1, 'Z': 1}
if self.REVERX.isChecked(): ReverDt['X'] = -1
if self.REVERY.isChecked(): ReverDt['Y'] = -1
if self.REVERZ.isChecked(): ReverDt['Z'] = -1
for i, DrivenInformations in enumerate(self.targentAtrLst):
DrivenAttr = str(list(self.Model.stringList())[i])
for driverValue, value in zip(DrivenInformations[2],
DrivenInformations[3]):
mc.setDrivenKeyframe(DrivenAttr,
cd=DrivenInformations[0],
dv=driverValue,
v=value *
ReverDt.get(DrivenInformations[0][-1], 1))
print DrivenInformations[0], DrivenAttr
def setSetDrivenKeyframeList(driver='', driverValueList=[], drivenList=[], drivenValueList=[]):
'''
Set driven keyframe "wrapper" for multiple driven objects and/or multiple dirver/driven keys
setSetDrivenKeyframeList( driver='Rt_indexFinger2_jnt.ry', driverValueList=[0,45,90], drivenList=['Rt_indexFinger2_bulge_helper.tz'], drivenValueList=[0,0,-.08] )
'''
if mc.objExists(driver):
for driven in drivenList:
if mc.objExists(driven):
for driverValue, drivenValue in zip(driverValueList, drivenValueList):
mc.setDrivenKeyframe(driven, cd=driver, value=drivenValue, driverValue=driverValue)
LOG.debug('Set setDrivenKeyframe for %s:%s --> %s:%s' % (driver, driverValue, driven, drivenValue))
else:
LOG.warning('Driver %s not found, skipping...' % driver)
def armIk(armIkScale, armikHandle, pvName):
ikHandJoint = cmds.joint(n=side + "hand_ik")
cmds.delete(cmds.parentConstraint(ogChain[2] + "_ik", ikHandJoint))
cmds.makeIdentity(ikHandJoint, a = 1, t = 1, r = 1, s = 0)
if side == "l_":
cmds.move(10,0,0, ikHandJoint, r=1, os=1)
else:
cmds.move(-10,0,0, ikHandJoint, r=1, os=1)
cmds.parent(ikHandJoint, ogChain[2] + "_ik")
handikHandle = cmds.ikHandle(sj=ogChain[2] + "_ik", ee=ikHandJoint, n=side + "hand_ikHandle", sol="ikSCsolver")
cmds.parent(handikHandle[0], armikHandle[0])
#create IK controller ---> CUBE
crvIkCube = cmds.curve(d=1, p=[(-0.5, 0.5, -0.5), (0.5, 0.5, -0.5), (0.5, 0.5, 0.5),
(-0.5, 0.5, 0.5), (-0.5, -0.5, 0.5), (-0.5, -0.5, -0.5),
(-0.5, 0.5, -0.5), (-0.5, 0.5, 0.5), (-0.5, -0.5, 0.5),
(0.5, -0.5, 0.5), (0.5, 0.5, 0.5), (0.5, 0.5, -0.5),
(0.5, -0.5, -0.5), (0.5, -0.5, 0.5), (0.5, -0.5, -0.5), (-0.5, -0.5, -0.5)],
k=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5], n=side + "hand_ik_anim" )
# Rename shape node
shapeList = cmds.listRelatives(crvIkCube, s = True)
cmds.rename(shapeList, crvIkCube + "Shape")
crvIkCubeGrp = cmds.group(n=crvIkCube + "_grp")
cmds.delete(cmds.parentConstraint(ogChain[2] + "_ik", crvIkCubeGrp))
cmds.color(crvIkCube, rgb=controllerColor)
cmds.scale(armIkScale, armIkScale, armIkScale, crvIkCubeGrp)
cmds.parent(armikHandle[0], crvIkCube)
pvController = createSphere(nome= side+pvName+"_PV")
findPoleVector(loc=pvController, targetHandle=armikHandle[0])
cmds.addAttr(pvController, at="enum", enumName = "------", ln="Attributes", k=1, r=1)
cmds.addAttr(pvController, ln="Follow", k=1, r=1, min=0, max=1)
cmds.addAttr(pvController, ln="Follow_Clav_Hand", k=1, r=1, min=0, max=1, dv=0.5)
# Parent ikController and PV under _rig_GRP
cmds.parent(crvIkCubeGrp, pvController + "_grp" ,rigGrp)
#set SDK visibility
sdkDriver = switcherLoc[0] + ".FKIK_Mode"
cmds.setAttr(sdkDriver, 0)
cmds.setDrivenKeyframe(crvIkCubeGrp + ".visibility", cd=sdkDriver, v=0, dv=0)
cmds.setDrivenKeyframe(pvController + "_grp.visibility", cd=sdkDriver, v=0, dv=0)
cmds.setAttr(sdkDriver, 1)
cmds.setDrivenKeyframe(crvIkCubeGrp + ".visibility", cd=sdkDriver, v=1, dv=1)
cmds.setDrivenKeyframe(pvController + "_grp.visibility", cd=sdkDriver, v=1, dv=1)
def makeSdk():
# Getting how many sdk's to create.
sdkNum = int(cmds.optionMenu('sdkOpt', q=True, v=True))
driverField = 'drFltFld'
drivenField = 'dnFltFld'
drivenList = queryAll('drvnTSL')
driver = queryDrvr()
i = 0
while (i < sdkNum):
# Get my values from the gui
drivenVal = cmds.floatField(drivenField + str(i + 1), q=True, v=True)
driverVal = cmds.floatField(driverField + str(i + 1), q=True, v=True)
for currDriven in drivenList:
cmds.setDrivenKeyframe(currDriven,
currentDriver=driver,
driverValue=driverVal,
value=drivenVal)
i = i + 1
def connect_sdk(self, action='current'):
'''Create Set Driven Keys for selected attributes using
source member as driver. (set in connect_from()).
Actions: current/forward/reverse.'''
plugs = self.get_plugs(self.connect_source)
source_sels = []
for s, d in plugs:
if action == 'current':
cmds.setDrivenKeyframe(d,
currentDriver=s,
itt='spline',
ott='spline')
elif action == 'reverse':
cmds.setDrivenKeyframe(d,
currentDriver=s,
itt='spline',
ott='spline',
driverValue=0,
value=1)
cmds.setDrivenKeyframe(d,
currentDriver=s,
itt='spline',
ott='spline',
driverValue=1,
value=0)
elif action == 'forward':
cmds.setDrivenKeyframe(d,
currentDriver=s,
itt='spline',
ott='spline',
driverValue=0,
value=0)
cmds.setDrivenKeyframe(d,
currentDriver=s,
itt='spline',
ott='spline',
driverValue=1,
value=1)
source_sels.append(s.rpartition('.')[0])
#cmds.select(source_sels, r=True)
return
def makeSdk(sdkOpt):
'''
Function that queries from the GUI and loops the desired SDK values
'''
try: # run code, but catch errors
# query the textFields and optionMenu to use values in SDK process
driver = queryDrvr()
# query the items from TSL to use values in SDK process
drivenList = dTSL.queryAll()
# query the optionMenu to determine how many iterations to loop
sdkNum = int(cmds.optionMenu(sdkOpt, q=True, v=True))
drName = "drFltFld"
dnName = "dnFltFld"
#declare counters for loop
i = 0
while (i < sdkNum):
drVal = cmds.floatField(drName + str(i + 1), q=True, v=True)
dnVal = cmds.floatField(dnName + str(i + 1), q=True, v=True)
for item in drivenList:
cmds.setDrivenKeyframe(item,
currentDriver=driver,
driverValue=drVal,
value=dnVal)
#increment counter
i += 1
except:
OpenMaya.MGlobal.displayWarning(
"Please load items into the driver and driven sections of the UI.")
def makeSdk( sdkOpt ): ''' Function that queries from the GUI and loops the desired SDK values ''' try: # run code, but catch errors # query the textFields and optionMenu to use values in SDK process driver = queryDrvr() # query the items from TSL to use values in SDK process drivenList = dTSL.queryAll() # query the optionMenu to determine how many iterations to loop sdkNum = int( cmds.optionMenu( sdkOpt, q=True, v=True ) ) drName = "drFltFld" dnName = "dnFltFld" #declare counters for loop i = 0 while ( i < sdkNum ): drVal = cmds.floatField( drName + str(i+1), q=True, v=True ) dnVal = cmds.floatField( dnName + str(i+1), q=True, v=True ) for item in drivenList: cmds.setDrivenKeyframe( item, currentDriver=driver, driverValue=drVal, value=dnVal ) #increment counter i += 1 except: OpenMaya.MGlobal.displayWarning( "Please load items into the driver and driven sections of the UI." )
def set_driven_key(driverInfo, drivenInfo, tangent="linear"):
"""Automate the set driven key through the use of set driven key
@param driverInfo (dict) list of values of the driver attribute. The key should be the target attribute
@param drivenInfo (dict) list of values of the driven attribute. The key should be the target attribute
@param tangent (str) The type of tangent to be used for the set driven key. Default is linear
@code
import libUtilities
#Set up the driver info
driverInfo = {"ctrl.tx":[0,1]}
drivenInfo = {"cube.rz":[0,360]}
libUtilities.setDrivenKey(driverInfo, drivenInfo )
@endcode
@warning The number of values in both driver and driven attribute should be same
"""
if type(driverInfo) != dict or type(drivenInfo) != dict:
raise RuntimeError("Not a dictInfo")
driver = driverInfo.keys()[0]
driven = drivenInfo.keys()[0]
currentDriverValue = cmds.getAttr(driver)
currentDrivenValue = cmds.getAttr(driven)
inTangents = outTangent = tangent
if tangent == "step":
inTangents = "clamped"
cmds.setDrivenKeyframe(driven, itt=inTangents, ott=outTangent, cd=driver)
for driveAttr, drivenAttr in zip(driverInfo[driver], drivenInfo[driven]):
cmds.setAttr(driver, driveAttr)
cmds.setAttr(driven, drivenAttr)
cmds.setDrivenKeyframe(driven, itt=inTangents, ott="linear", cd=driver)
cmds.setAttr(driver, currentDriverValue)
cmds.setAttr(driven, currentDrivenValue)
def hook(self):
"""@todo: insert doc for hook"""
hook_fk = '%s_%s_%s_%s_%s' % (self.side, 'leg', 'FK_foot', 'hook', self.nc['locator'])
hook_ik = '%s_%s_%s_%s_%s' % (self.side, 'leg', 'IK_foot', 'hook', self.nc['locator'])
cmds.parentConstraint(hook_fk, '%s_%s_%s' % (self.side, 'foot_const', self.nc['group']), mo=True, weight=1)
constr = cmds.parentConstraint(hook_ik, '%s_%s_%s' % (self.side, 'foot_const', self.nc['group']), mo=True, weight=1)[0]
cmds.parent('%s_legSpring_%s' % (self.side, self.nc['ikhandle']), '%s_toePalmMid_%s' % (self.side, self.nc['locator']))
settings = '%s_legSettings_%s' % (self.side, self.nc['control'])
cmds.setDrivenKeyframe('%s.%s_leg_FK_foot_hook_LOCW0' % (constr, self.side), cd='%s.FK_IK_Blend' % settings, dv=0, v=1)
cmds.setDrivenKeyframe('%s.%s_leg_IK_foot_hook_LOCW1' % (constr, self.side), cd='%s.FK_IK_Blend' % settings, dv=0, v=0)
cmds.setDrivenKeyframe('%s.%s_leg_FK_foot_hook_LOCW0' % (constr, self.side), cd='%s.FK_IK_Blend' % settings, dv=1, v=0)
cmds.setDrivenKeyframe('%s.%s_leg_IK_foot_hook_LOCW1' % (constr, self.side), cd='%s.FK_IK_Blend' % settings, dv=1, v=1)
# connect attributes
arm_settings = '%s_legSettings_%s' % (self.side, self.nc['control'])
cmds.connectAttr('%s.FK_IK_Blend' % self.controls['foot'], '%s.FK_IK_Blend' % arm_settings, f=True)
cmds.connectAttr('%s.FK_Rotation_Space' % self.controls['foot'], '%s.FK_Rotation_Space' % arm_settings, f=True)
cmds.connectAttr('%s.stretch' % self.controls['foot'], '%s.stretch' % arm_settings, f=True)
def on_actionSetkeys_triggered(self, clicked=None):
if clicked==None:return
if not os.path.exists('D:/toe.json'):return
# open File
f = open('D:/toe.json', 'r')
ControlNameData = json.load(f)
f.close()
# get Axis
Axis = 'ry'
if self.axisXRDN.isChecked():
Axis = 'rx'
elif self.axisYRDN.isChecked():
Axis = 'ry'
else:
Axis = 'rz'
# get Value
DvnMinValue = self.minFLD.value()
DvnMaxValue = self.maxFLD.value()
if self.reverseBOX.isChecked():
Reverse = 1
else:
Reverse = -1
#---
print '-*-' * 20
print '\n'
for Driver, Drivens in ControlNameData.iteritems():
if not mc.objExists(Driver):continue
DriverMinV = mc.addAttr('%s.spread'%Driver, q=True, min=True)
DriverMaxV = mc.addAttr('%s.spread'%Driver, q=True, max=True)
Drivens = [x for i, x in enumerate(Drivens) if x not in Drivens[:i]]
Counts = len(Drivens)
for i, Driven in enumerate(Drivens):
#- Driven Open
mc.setDrivenKeyframe('%s.%s'%(Driven, Axis), cd='%s.spread'%Driver, dv=0, v=0)
DrivenrotateV = self.setRange(i * 1.0, 0, Counts-1, DvnMaxValue*-1, DvnMaxValue)
mc.setDrivenKeyframe('%s.%s'%(Driven, Axis), cd='%s.spread'%Driver, dv=DriverMaxV, v=DrivenrotateV * Reverse)
#- Driven Close
DrivenrotateV = self.setRange(i * 1.0, 0, Counts-1, DvnMinValue, DvnMinValue * -1)
mc.setDrivenKeyframe('%s.%s'%(Driven, Axis), cd='%s.spread'%Driver, dv=DriverMinV, v=DrivenrotateV * -1 * Reverse)
#--- output ---
print 'cmds.setDrivenKeyframe("%s.%s", cd="%s.spread", dv=0, v=0)'%(Driven, Axis, Driver)
print 'cmds.setDrivenKeyframe("%s.%s", cd="%s.spread", dv=%f, v=%f)'%(Driven, Axis, Driver, DriverMaxV, DrivenrotateV * Reverse)
print 'cmds.setDrivenKeyframe("%s.%s", cd="%s.spread", dv=%f, v=%f)'%(Driven, Axis, Driver, DriverMinV, DrivenrotateV * -1 * Reverse)
print '\n'
print '-*-' * 20
if self.deleteFilesCBX.isChecked():
os.remove('D:/toe.json')
def _foot_attributes(self, ikhandles):
"""Creates additional attributes for the foot.
@param ikhandles: the ik handles
@type ikhandles: list
"""
inner = cmds.spaceLocator(n='%s_inner_%s' % (self.side, self.nc.locator))[0]
outer = cmds.spaceLocator(n='%s_outer_%s' % (self.side, self.nc.locator))[0]
self.c.snap_a_to_b(inner, '%s_%s_%s' % (self.side, 'inner', self.nc.guide))
self.c.snap_a_to_b(outer, '%s_%s_%s' % (self.side, 'outer', self.nc.guide))
cmds.parent(inner, outer)
cmds.parent(outer, '%s_heel_%s' % (self.side, self.nc.locator))
cmds.parent('%s_ball_%s' % (self.side, self.nc.ikhandle), '%s_toe_%s' % (self.side, self.nc.locator), inner)
cmds.addAttr(self.controls['ik'], ln='tilt', at='double', dv=0)
cmds.setAttr('%s.tilt' % self.controls['ik'], e=True, keyable=True)
cmds.setDrivenKeyframe('%s.rotateZ' % inner, cd='%s.tilt' % self.controls['ik'], dv=0, v=0)
cmds.setDrivenKeyframe('%s.rotateZ' % outer, cd='%s.tilt' % self.controls['ik'], dv=0, v=0)
cmds.setDrivenKeyframe('%s.rotateZ' % inner, cd='%s.tilt' % self.controls['ik'], dv=90, v=-90)
cmds.setDrivenKeyframe('%s.rotateZ' % outer, cd='%s.tilt' % self.controls['ik'], dv=-90, v=90)
cmds.addAttr(self.controls['ik'], ln='lean', at='double', dv=0)
cmds.setAttr('%s.lean' % self.controls['ik'], e=True, keyable=True)
cmds.addAttr(self.controls['ik'], ln='toeSpin', at='double', dv=0)
cmds.setAttr('%s.toeSpin' % self.controls['ik'], e=True, keyable=True)
cmds.connectAttr('%s.lean' % self.controls['ik'], '%s_ball_%s.rotateZ' % (self.side, self.nc.locator), f=True)
cmds.connectAttr('%s.toeSpin' % self.controls['ik'], '%s_toe_%s.rotateY' % (self.side, self.nc.locator), f=True)
cmds.setAttr('%s_ball_%s.rotateOrder' % (self.side, self.nc.locator), 2)
cmds.addAttr(self.controls['ik'], ln='toeWiggle', at='double', dv=0)
cmds.setAttr('%s.toeWiggle' % self.controls['ik'], e=True, keyable=True)
grp = cmds.group(ikhandles[2], n='%s_toeWiggle_%s' % (self.side, self.nc.group))
pos = self.c.move_pivot_to(self.guides['ball'][0],
self.guides['ball'][1],
self.guides['ball'][2], grp)
cmds.connectAttr('%s.toeWiggle' % self.controls['ik'], '%s.rotateX' % grp, f=True)
cmds.parent(grp, '%s_toe_%s' % (self.side, self.nc.locator))
def create_spread(self):
"""Creates the automated spread attribute."""
ctl = self.controls['hand']
for finger in self.fk_jnts:
if len(self.fk_jnts[finger]) == 0:
continue
# END if
if finger == 'base' or finger == 'thumb':
continue
# END if
for i in range(1, 4):
driven = '%s_%s%s_FK_compound_JNT' % (self.side, finger, i)
cmds.setDrivenKeyframe('%s.rotateY' % driven, cd='%s.spread' % ctl, dv=0, v=0)
# END for
for i in range(1, 4):
driven = '%s_%s%s_FK_compound_JNT' % (self.side, finger, i)
if finger=='pointer':
mult = 4.5
elif finger=='middle':
mult = 3.3
elif finger=='ring':
mult = 2.3
elif finger=='pinky':
mult = 1.1
elif finger=='extra':
mult = 0.2
# END if
v = 5 * (i-3.2) * mult
cmds.setDrivenKeyframe('%s.rotateY' % driven, cd='%s.spread' % ctl, dv=-10, v=v)
# END for
for i in range(1, 4):
driven = '%s_%s%s_FK_compound_JNT' % (self.side, finger, i)
if finger=='pointer':
mult = 4.5
elif finger=='middle':
mult = 3.3
elif finger=='ring':
mult = 2.3
elif finger=='pinky':
mult = 1.1
elif finger=='extra':
mult = 0.2
# ENd if
v = -5 * (i-3.2) * mult
cmds.setDrivenKeyframe('%s.rotateY' % driven, cd='%s.spread' % ctl, dv=10, v=v)
def key_attr(*args):
selection = cmds.ls(sl=True)
attr_name = cmds.textField(attr_field, q=True, tx=True)
key_min = cmds.intField(attr_min, q=True, v=True)
key_max = cmds.intField(attr_max, q=True, v=True)
axis = cmds.radioButtonGrp(button_grp, q=True, sl=True)
if selection != 2:
print 'Your selection is incorrect.'
if axis == 1:
axis = 'x'
elif axis == 2:
axis = 'y'
elif axis == 3:
axis = 'z'
else:
print 'Must have an asix selected.'
key_min = -key_min
key_max = -key_max
driver = selection[1] + '.' + attr_name
driven = selection[0] + '.r' + axis
print driver
print driven
cmds.setAttr(driver, 0)
cmds.setAttr(driven, 0)
cmds.setDrivenKeyframe(driven, cd=driver)
cmds.setAttr(driver, key_min)
cmds.setAttr(driven, key_min)
cmds.setDrivenKeyframe(driven, cd=driver)
cmds.setAttr(driver, key_max)
cmds.setAttr(driven, key_max)
cmds.setDrivenKeyframe(driven, cd=driver)
cmds.setAttr(driver, 0)
def connectWristAttributeToFinger(self, channelList, attributeSuffix="", minVal=-10, maxVal=10, pos=1, neg=1):
for fingerItem in self.wristFingersList:
if fingerItem == "thumb":
continue
fingerList = self.wristFingersList[fingerItem]
for element in fingerList:
jointItem = fingerList[element]
if attributeSuffix:
attributeName = jointItem.baseName + "_" + attributeSuffix
else:
attributeName = jointItem.joint
driver = self.wristControl + '.' + attributeName
setDrivenKeyGroup = jointItem.setDrivenKey
for channel in channelList:
attr = (channel[0] + channel[-1]).lower()
attrExists = cmds.attributeQuery(attributeName, node= self.wristControl, ex=True )
if attrExists:
cmds.setAttr(driver, 0)
cmds.setAttr(setDrivenKeyGroup + "." + attr, 0)
cmds.setDrivenKeyframe(setDrivenKeyGroup, at=channel, cd=driver)
if pos:
cmds.setAttr(driver, maxVal)
cmds.setAttr(setDrivenKeyGroup + "." + attr, 50)
cmds.setDrivenKeyframe(setDrivenKeyGroup, at=channel, cd=driver)
if neg:
cmds.setAttr(driver, minVal)
cmds.setAttr(setDrivenKeyGroup + "." + attr, -50)
cmds.setDrivenKeyframe(setDrivenKeyGroup, at=channel, cd=driver)
#reset to 0
cmds.setAttr(driver, 0)
