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)