def create_attr(self): # Create enum attribute on selected control object sel = pm.ls(selection=True) if not sel: pm.displayWarning("Select Control object") return None attr = self.attr_nm.getText() attr_lst = self.enum_val.getText().split("\n") enum_attr_val = "" for index in range(len(attr_lst)): if attr_lst[index]: enum_attr_val += attr_lst[index] if not index == len(attr_lst) - 1: enum_attr_val += ":" for obj in sel: pm.addAttr(obj, longName=attr, attributeType="enum", enumName=enum_attr_val, keyable=True, readable=True, storable=True, writable=True) self.populate_list() return None
def initializeSet(self, *args): self.vraySettings = pm.PyNode('vraySettings') if pm.attributeQuery('deeXVrayFastOptimized', n=self.vraySettings.name(), ex=True): self.deeXVrayFastOptimized = True self.vraySettings.samplerType.set(1) if not pm.attributeQuery('deeXVrayFastLastQuality', n=self.vraySettings.name(), ex=True): self.deeXVrayFastLastQuality = 50 locked = False if pm.lockNode(self.vraySettings.name(), query=True, lock=True)[0]: locked = True pm.lockNode(self.vraySettings.name(), lock=False) pm.addAttr(self.vraySettings.name(), ln='deeXVrayFastLastQuality', at='long') if locked: pm.lockNode(self.vraySettings.name(), lock=True) self.vraySettings.deeXVrayFastLastQuality.set(self.deeXVrayFastLastQuality) else: self.deeXVrayFastLastQuality = self.vraySettings.deeXVrayFastLastQuality.get()
def saveSetting(self, *args): dicoAttr = {} for myAttr in pm.listAttr(self.vraySettings.name()): try: dicoAttr[myAttr] = pm.getAttr('vraySettings.' + myAttr) except: OpenMaya.MGlobal.displayInfo('[Arsenal Quality] ' + myAttr + ' value can not be saved or have not value.') if not pm.attributeQuery('deeXVrayFastActualSettings', n=self.vraySettings.name(), ex=True): locked = False if pm.lockNode(self.vraySettings.name(), query=True, lock=True)[0]: locked = True pm.lockNode(self.vraySettings.name(), lock=False) pm.addAttr(self.vraySettings.name(), ln='deeXVrayFastActualSettings', dt='string') if locked: pm.lockNode(self.vraySettings.name(), lock=True) self.vraySettings.deeXVrayFastActualSettings.set(str(dicoAttr))
def getParentAttr(self, obj, createOnMissing=False, useCurrentIfCreating=False): assert isinstance(obj, pymel.core.nodetypes.Transform) parAttr = None try: parAttr = obj.mmmmRiggerIntendedParent except: ## don't actually create the attribute unless if createOnMissing: pm.addAttr( obj, ln='mmmmRiggerIntendedParent', at='message' ) parAttr = obj.mmmmRiggerIntendedParent if useCurrentIfCreating: parObject = obj.getParent() if not parObject is None: parObj.message >> parAttr return parAttr
def ckAddFidget(): """ ckAddFidget( ) description: this function collects the selected attribute and adds it to the list of data that fidget will work with inputs: None outputs: None CK - this would be a great place to add data to a persistent node in the maya file(working) """ # fist we are collecting the selected attribute atribSel = pm.mel.eval('selectedChannelBoxAttributes();') # then we get the object said attribute belongs to slectItm = pm.ls( selection = True ) # the two are added together so we can work with the information # inside the maya context newAttr = slectItm.pop() + '.' + atribSel.pop() # this is a test to ensure that we are in fact getting some kind of data from # the attribute newVal = pm.getAttr( newAttr ) print newVal pm.select( clear = True ) # given that has worked we will add the data to the lists ckAddToList( "ckFidget_GRP.ckFidgetList", newAttr) ckAddToList( "ckFidget_GRP.ckFidgetSav", newVal) pm.group(name = str(newAttr+"_SAV0" )) pm.addAttr( longName="fdgSave", dataType="string", keyable=False) newAttr = newAttr.split(".") pm.setAttr( str(newAttr[0]+"_"+newAttr[1]+"_SAV0.fdgSave"), str(newVal)) pm.select( "ckFidget_GRP") pm.parent( str(newAttr[0]+"_"+newAttr[1]+"_SAV0") ) pm.select( clear = True ) pm.select(newAttr[0]) # now issue the call to rebuild the interface ckFidgetWin()
def optimize(self): self.deeXVrayFastOptimized = True locked = False if pm.lockNode(self.vraySettings.name(), query=True, lock=True)[0]: locked = True pm.lockNode(self.vraySettings.name(), lock=False) if not pm.attributeQuery('deeXVrayFastOptimized', n=self.vraySettings.name(), ex=True): pm.addAttr(self.vraySettings.name(), ln='deeXVrayFastOptimized', at='bool') self.vraySettings.deeXVrayFastOptimized.set(1) pm.addAttr(self.vraySettings.name(), ln='deeXVrayFastLastQuality', at='long') self.vraySettings.deeXVrayFastLastQuality.set(50) pm.addAttr('vraySettings', ln='deeXVrayFastLastTypePreset', dt='string') self.vraySettings.deeXVrayFastLastTypePreset.set('deeX_interior') pm.addAttr('vraySettings', ln='deeXVrayFastLastPresetPreComp', dt='string') self.vraySettings.deeXVrayFastLastPresetPreComp.set('deeX_basic') pm.addAttr('vraySettings', ln='deeXVrayFastoptimizationChooserSettings', dt='string') self.vraySettings.deeXVrayFastoptimizationChooserSettings.set("{'OptimizationChooserGlobalOptionInt': [False, 0], 'OptimizationChooserImageSamplerInt': [False, 0], 'OptimizationChooserDMCSamplerInt': [False, 0], 'OptimizationChooserIrradianceMapInt': [False, 0], 'OptimizationChooserLightCacheInt': [False, 0], 'OptimizationChooserSystemInt': [False, 0]}") if locked: pm.lockNode(self.vraySettings.name(), lock=True) self.initAttributes() self.refresh()
def treadAtPoints(**kwargs): #get inputs tread_name = kwargs.get("tr_name", "Tread") crv = kwargs.get("path_crv", None) crv = str(pm.duplicate(crv, name=str(tread_name) + "PathCrv")[0]) pm.xform(crv, centerPivots=True) #obtain curve length full_length = pm.arclen(crv) paramVal = [] uVal = [] # get param value on the curve at each position selected (locators) sel_obj = pm.ls(selection=True) for obj in sel_obj: pos = pm.xform(obj, query=True, translation=True, worldSpace=True) param = getuParamVal(pos, crv) paramVal.append(param) crv_shp = pm.listRelatives(crv, shapes=True)[0] # create arc length dimension tool arcLen = pm.arcLengthDimension(crv_shp + ".u[0]") # for each param value obtained set the arc length tool attribute and # store the length of curve at that param value # normalize the curve to obtain the motion path U value at each position for val in paramVal: pm.setAttr(str(arcLen) + ".uParamValue", val) len_at_pos = pm.getAttr(str(arcLen) + ".arcLength") uVal.append(len_at_pos / full_length) pm.delete(arcLen) mthPthLst = [] jntLst = [] # create joints, assign motion path and set U value obtained for u in uVal: pm.select(clear=True) jnt = pm.joint() jntLst.append(jnt) pathanim = pm.pathAnimation(jnt, curve=crv, fractionMode=True, follow=True, followAxis="x", worldUpType="vector", worldUpVector=(0, 1, 0)) mthPthLst.append(pathanim) pm.setAttr(str(pathanim) + ".uValue", u) pm.disconnectAttr(str(pathanim) + ".u") # create up locator at mid point of all joints #loc_pos = midPos(selected_items = jntLst) #loc_pos = pm.xform(crv, query=True, translation=True, worldSpace=True) loc_pos = midPosVec(objects=jntLst) loc = pm.spaceLocator() pm.xform(loc, translation=loc_pos, worldSpace=True) for mtPth in mthPthLst: pm.pathAnimation(mtPth, edit=True, worldUpType="object", worldUpObject=loc) # create control curve, add run and speed attributes control_crv = pm.circle(name=tread_name + "CTRL", normalX=1, normalY=0, normalZ=0) pm.xform(control_crv, translation=loc_pos) pm.select(clear=True) pm.addAttr(control_crv, longName="run", attributeType="float", keyable=True) pm.addAttr(control_crv, longName="speed", attributeType="float", keyable=True, minValue=0.0, defaultValue=0.5) # group the tread setup pm.parent(crv, control_crv) pm.parent(loc, control_crv) pm.select(clear=True) gp = pm.group(name=tread_name + "GP") pm.select(clear=True) jnt_gp = pm.group(jntLst, name=tread_name + "JNTGP") pm.xform(gp, translation=loc_pos) pm.parent(control_crv, gp) pm.parent(jnt_gp, gp) createTreadExpression(mtnPth=mthPthLst, runAttr=str(control_crv[0]) + ".run", speedAttr=str(control_crv[0]) + ".speed", exp_nm=tread_name) return None #treadAtPoints(pathCrv = "nurbsCircle1", tr_name = "testTread")
def makeAnimCtrlAndZero(self, doConnectPosSlave=True, doConnectRotSlave=True): ctrls = [] objs = pm.ls(selection=True) for obj in objs: ## really, you have to find the first occurance of the numbered name ## that didn't exist in the scene as either a zero or a control goodNumber = None iter = 0 while goodNumber == None and iter < 99: iter+=1 if iter==0: foundZ = pm.ls( obj.name() + "_zero" ) foundC = pm.ls( obj.name() + "_ctrl" ) if len(foundZ)==0 and len( foundC )==0: goodNumber = 0 else: foundZ = pm.ls( obj.name() + str(iter) + "_zero" ) ## could use .zfill(2) foundC = pm.ls( obj.name() + str(iter) + "_ctrl" ) if len(foundZ)==0 and len( foundC )==0: goodNumber = iter if goodNumber == 0: basename = obj.name() else: basename = obj.name() + str(goodNumber) try: jointRadius=obj.radius.get() except: print( traceback.format_exc() ) jointRadius=16 radiusToUse = self.ctrlSizeFloatField.getValue() if radiusToUse <= 0.0: radiusToUse = 8*jointRadius ctrlList = pm.circle(normal=[1,0,0], radius=radiusToUse, ch=False) #ctrlCircle = ctrlList[1] ctrl = ctrlList[0] pm.rename( ctrl, basename + "_ctrl" ) pCon = pm.pointConstraint( obj, ctrl ) oCon = pm.orientConstraint( obj, ctrl ) ## beware, pymel returns constraints back directly, not in list pm.delete( [pCon, oCon] ) ## delte constraints zeroList = pm.duplicate( ctrl ) zero = zeroList[0] pm.rename( zero, basename + "_zero") pm.delete( zero.getShape() ) pm.parent( ctrl, zero ) #pCon = pm.pointConstraint( ctrl, obj ) #oCon = pm.orientConstraint( ctrl, obj ) pm.addAttr( ctrl, ln='posSlave', at='message' ) pm.addAttr( ctrl, ln='rotSlave', at='message' ) if doConnectPosSlave==True: obj.message >> ctrl.posSlave if doConnectRotSlave==True: obj.message >> ctrl.rotSlave ctrls.append( ctrl ) pm.select( ctrls )
def _postCreateVirtual(cls, newNode): """ This is called before creation, pymel/cmds allowed.""" pymel.addAttr(newNode, longName='_class', dataType='string') newNode._class.set('_JointNode')
def setup_ik_spline(**kwargs): curve = kwargs.get("curve", None) joint_chain = kwargs.get("joint_chain", None) auto_curve = kwargs.get("auto_curve", True) use_curve = kwargs.get("use_curve", None) spans = kwargs.get("number_of_spans", 4) ctrl_jnts = kwargs.get("num_control_joints", 3) ik_name = kwargs.get("ik_name", "ikHandle") scale_stretch = kwargs.get("scale_stretch", False) create_dense_chain = kwargs.get("dense_chain", False) dense_division = kwargs.get("dense_chain_divisions", 3) auto_simplify = kwargs.get("auto_simplify_curve", False) stretch_exp = kwargs.get("stretch_exp", False) global_scale_check = kwargs.get("global_scale_check", False) global_scale_attr = kwargs.get("global_scale_attr", None) pm.select(joint_chain, hierarchy=True) joint_chain = pm.ls(selection=True) if not isinstance(joint_chain[0], pm.Joint): pm.displayInfo("selection should be of type joint") return None if len(joint_chain) < 2: pm.displayInfo("Chain should consist of more than one joint") return None if (global_scale_check): if (global_scale_attr is None): pm.displayInfo("Please input global scale attribute") return None else: obj = global_scale_attr.split(".")[0] global_attr = global_scale_attr.split(".")[1] check_global_attr = pm.attributeQuery(global_attr, node=obj, exists=True) if not check_global_attr: pm.displayInfo("Invalid global scale attribute") return None start_jnt = joint_chain[0] end_joint = joint_chain[-1] if create_dense_chain: rep_chain = pm.duplicate(joint_chain) start_jnt = rep_chain[0] end_joint = rep_chain[-1] dense_chain(joints=rep_chain, joints_inbetween=dense_division) rep_chain.append(end_joint) for index in range(len(joint_chain)): pm.parentConstraint(rep_chain[index], joint_chain[index], maintainOffset=False) #pm.scaleConstraint(rep_chain[index], joint_chain[index], maintainOffset=False) pm.connectAttr( str(rep_chain[index]) + ".scale", str(joint_chain[index]) + ".scale") pm.select(start_jnt, hierarchy=True) new_chain = pm.ls(selection=True) crv = "" #print "START", start_jnt #print "END",end_joint if auto_curve: ik_handle, eff, crv = pm.ikHandle(startJoint=start_jnt, createCurve=auto_curve, solver="ikSplineSolver", numSpans=spans, endEffector=end_joint, simplifyCurve=auto_simplify) else: crv = pm.PyNode(use_curve) ik_handle, eff = pm.ikHandle(startJoint=start_jnt, curve=use_curve, solver="ikSplineSolver", endEffector=end_joint, createCurve=False) crv.inheritsTransform.set(0) pm.rename(ik_handle, ik_name + "IK_Handle") pm.rename(crv, ik_name + "IK_Curve") ik_curve_shp = crv.getShape() crv_info_node = pm.createNode("curveInfo") pm.connectAttr(ik_curve_shp + ".worldSpace", crv_info_node + ".inputCurve") ''' if stretch_exp: if create_dense_chain: stretch_expression(joints = new_chain, curve_info_node = crv_info_node, connect_scale = scale_stretch, expression_name = ik_name+"_stretch_expression") else: stretch_expression(joints = joint_chain, curve_info_node = crv_info_node, connect_scale = scale_stretch, expression_name = ik_name+"_stretch_expression") ''' if ctrl_jnts: if ctrl_jnts == 1: print "Minimum 2 joints needed as controllers" print "skipping control joint creation process" pm.displayInfo("Minimum 2 joints needed as controllers") else: ctrl_jnts = joints_along_curve(number_of_joints=ctrl_jnts, curve=crv, bind_curve_to_joint=True) pm.select(clear=True) ctr_jnt_gp = pm.group(ctrl_jnts, name="control_joints") #print "JNT NAME", ctr_jnt_gp if stretch_exp: pm.addAttr(ctrl_jnts[-1], longName="Stretch", attributeType="enum", enumName="off:on", keyable=True) print "ATTRIBUTE TO", str(ctrl_jnts[-1]) if create_dense_chain: stretch_expression(joints=new_chain, curve_info_node=crv_info_node, connect_scale=scale_stretch, expression_name=ik_name + "_stretch_expression", ctrl_attr=str(ctrl_jnts[-1]) + ".Stretch", glbl_scl_stat=global_scale_check, glbl_scl_attr=global_scale_attr) else: stretch_expression(joints=joint_chain, curve_info_node=crv_info_node, connect_scale=scale_stretch, expression_name=ik_name + "_stretch_expression", ctrl_attr=str(ctrl_jnts[-1]) + ".Stretch", glbl_scl_stat=global_scale_check, glbl_scl_attr=global_scale_attr) final_group = pm.group(name=ik_name + "_ik_group", empty=True) pm.parent(joint_chain[0], final_group) pm.parent(crv, final_group) pm.parent(ik_handle, final_group) if ctrl_jnts > 1: pm.parent(ctr_jnt_gp, final_group) if create_dense_chain: pm.select(clear=True) dense_grp = pm.group(start_jnt, name="dense_chain_group") pm.parent(dense_grp, final_group) return None
def createCtrl(self, name): #cameraName = camera[0].name() cameraShape = self.camera.getShape() # 그룹 리깅 constraint = pm.group(n=name + "_constraint", em=True) offset = pm.group(n=name + "_offset") shakeTransform = pm.group(n=name + "_Shake") offsetTz = pm.group(n=name + "_offsetTz") offsetTy = pm.group(n=name + "_offsetTy") offsetTx = pm.group(n=name + "_offsetTx") tz = pm.group(n=name + "_tz") rz = pm.group(n=name + "_rz") rx = pm.group(n=name + "_rx") ry = pm.group(n=name + "_ry") ctrl = pm.group(n=name + "_Ctrl") pm.setAttr(ctrl + ".displayHandle", 1) pm.setAttr(ctrl + ".overrideEnabled", 1) pm.setAttr(ctrl + ".overrideColor", 7) #dark_green # Display dispGrp = pm.group(n=name + "_Template_Grp", em=1) pm.parent(dispGrp, ctrl) pm.setAttr(dispGrp + ".overrideEnabled", 1) pm.setAttr(dispGrp + ".overrideDisplayType", 1) pm.setAttr(dispGrp + ".overrideColor", 7) #dark_green dispNodeList = [] dispNodeList.extend(self.displayConnect([ctrl, tz])) dispNodeList.extend(self.displayConnect([tz, offsetTx])) dispNodeList.extend(self.displayConnect([offsetTx, offsetTy])) dispNodeList.extend(self.displayConnect([offsetTy, offsetTz])) # Outline for dispNode in dispNodeList: dispNode.rename(name + '_' + dispNode.name()) pm.parent(dispNodeList, dispGrp) # Add attribute # Camera attribute pm.addAttr(ctrl, ln="Camera", en="Option:", at="enum") pm.setAttr(ctrl + ".Camera", e=1, channelBox=True) pm.addAttr(ctrl, ln="focalLength", dv=35, at='double', nn="FocalLength (mm)", keyable=True) pm.addAttr(ctrl, ln="overscan", dv=1, at='double', nn="Overscan", keyable=True) pm.addAttr(ctrl, ln="frameRange", at='double2', nn="Frame Range (frame)") pm.addAttr(ctrl, ln="startFrame", p='frameRange', at='double', nn="Start Frame", keyable=True) pm.addAttr(ctrl, ln="endFrame", p='frameRange', at='double', nn="End Frame", keyable=True) # Tumble attribute pm.addAttr(ctrl, ln="Tumble", en="Option:", at="enum") pm.setAttr(ctrl + ".Tumble", e=1, channelBox=True) pm.addAttr(ctrl, ln="tumbleTranslateZ", at='double', nn="Tumble Translate Z", keyable=True) pm.addAttr(ctrl, ln="tumbleRotate", at='double3', nn="Tumble Rotate") pm.addAttr(ctrl, ln="tumbleRotateX", p='tumbleRotate', at='double', nn="Tumble Rotate X", keyable=True) pm.addAttr(ctrl, ln="tumbleRotateY", p='tumbleRotate', at='double', nn="Tumble Rotate Y", keyable=True) pm.addAttr(ctrl, ln="tumbleRotateZ", p='tumbleRotate', at='double', nn="Tumble Rotate Z", keyable=True) # Shake attribute pm.addAttr(ctrl, ln="Shake", en="Option:", at="enum") pm.setAttr(ctrl + ".Shake", e=1, channelBox=True) pm.addAttr(ctrl, ln="time", keyable=False, at='double', nn="Shake Time (second)") pm.addAttr(ctrl, ln="timeOffset", keyable=False, at='double', nn="Shake Time Offset (second)") pm.addAttr(ctrl, ln="shake1", at='double2', nn=u"Shake 1st (진폭, 주기)") pm.addAttr(ctrl, ln="shakeAmplitude1", p='shake1', at='double', nn=u"Shake 1st (진폭)", keyable=True) pm.addAttr(ctrl, ln="shakeFrequency1", p='shake1', at='double', nn=u"Frequency 1st (주기)", keyable=True) pm.addAttr(ctrl, ln="noise1", at='double3', nn="Shake Noise 1st") pm.addAttr(ctrl, ln="noise1X", p='noise1', at='double', nn="Shake Noise 1 X") pm.addAttr(ctrl, ln="noise1Y", p='noise1', at='double', nn="Shake Noise 1 Y") pm.addAttr(ctrl, ln="noise1Z", p='noise1', at='double', nn="Shake Noise 1 Z") pm.addAttr(ctrl, ln="shake2", at='double2', nn=u"Shake 2nd (진폭, 주기)") pm.addAttr(ctrl, ln="shakeAmplitude2", p='shake2', at='double', nn=u"Shake 2nd (진폭)", keyable=True) pm.addAttr(ctrl, ln="shakeFrequency2", p='shake2', at='double', nn=u"Frequency 2nd (주기)", keyable=True) pm.addAttr(ctrl, ln="noise2", at='double3', nn="Shake Noise 2nd") pm.addAttr(ctrl, ln="noise2X", p='noise2', at='double', nn="Shake Noise 2 X") pm.addAttr(ctrl, ln="noise2Y", p='noise2', at='double', nn="Shake Noise 2 Y") pm.addAttr(ctrl, ln="noise2Z", p='noise2', at='double', nn="Shake Noise 2 Z") pm.addAttr(ctrl, ln="shakeTranslate", at='double3', nn="Shake Translate") pm.addAttr(ctrl, ln="shakeTranslateX", p='shakeTranslate', at='double', nn="Shake Translate X", keyable=True) pm.addAttr(ctrl, ln="shakeTranslateY", p='shakeTranslate', at='double', nn="Shake Translate Y", keyable=True) pm.addAttr(ctrl, ln="shakeTranslateZ", p='shakeTranslate', at='double', nn="Shake Translate Z", keyable=True) pm.addAttr(ctrl, ln="shakeRotate", at='double3', nn="Shake Rotate") pm.addAttr(ctrl, ln="shakeRotateX", p='shakeRotate', at='double', nn="Shake Rotate X", keyable=True) pm.addAttr(ctrl, ln="shakeRotateY", p='shakeRotate', at='double', nn="Shake Rotate Y", keyable=True) pm.addAttr(ctrl, ln="shakeRotateZ", p='shakeRotate', at='double', nn="Shake Rotate Z", keyable=True) pm.addAttr(ctrl, ln="shakeScale", at='double', dv=1.0, keyable=True) pm.addAttr(ctrl, ln="timeScale", at='double', dv=1.0, keyable=True) # Offset attribute pm.addAttr(ctrl, ln="Offset", en="Option:", at="enum") pm.setAttr(ctrl + ".Offset", e=1, channelBox=True) pm.addAttr(ctrl, ln="offsetTranslate", at='double3', nn="Offset Translate") pm.addAttr(ctrl, ln="offsetTranslateX", p='offsetTranslate', at='double', nn="Offset Translate X", keyable=True) pm.addAttr(ctrl, ln="offsetTranslateY", p='offsetTranslate', at='double', nn="Offset Translate Y", keyable=True) pm.addAttr(ctrl, ln="offsetTranslateZ", p='offsetTranslate', at='double', nn="Offset Translate Z", keyable=True) pm.addAttr(ctrl, ln="offsetRotate", at='double3', nn="Offset Rotate") pm.addAttr(ctrl, ln="offsetRotateX", p='offsetRotate', at='double', nn="Offset Rotate X", keyable=True) pm.addAttr(ctrl, ln="offsetRotateY", p='offsetRotate', at='double', nn="Offset Rotate Y", keyable=True) pm.addAttr(ctrl, ln="offsetRotateZ", p='offsetRotate', at='double', nn="Offset Rotate Z", keyable=True) # Display attribute pm.addAttr(ctrl, ln="Display", en="Option:", at="enum") pm.setAttr(ctrl + ".Display", e=1, channelBox=True) pm.addAttr(ctrl, ln="cameraScale", dv=1, at='double', nn="Camera Scale", keyable=True) pm.addAttr(ctrl, en="off:on:", nn="Display Ctrler", ln="displayCtrler", keyable=1, at="enum", dv=1) # Connect Attr pm.connectAttr(ctrl + ".cameraScale", name + ".sx") pm.connectAttr(ctrl + ".cameraScale", name + ".sy") pm.connectAttr(ctrl + ".cameraScale", name + ".sz") pm.connectAttr(ctrl + ".focalLength", cameraShape + ".focalLength") pm.connectAttr(ctrl + ".overscan", cameraShape + ".overscan") pm.connectAttr(ctrl + ".tumbleRotateX", rx + ".rx") pm.connectAttr(ctrl + ".tumbleRotateY", ry + ".ry") pm.connectAttr(ctrl + ".tumbleRotateZ", rz + ".rz") pm.connectAttr(ctrl + ".tumbleTranslateZ", tz + ".tz") pm.connectAttr(ctrl + ".offsetTranslateX", offsetTx + ".tx") pm.connectAttr(ctrl + ".offsetTranslateY", offsetTy + ".ty") pm.connectAttr(ctrl + ".offsetTranslateZ", offsetTz + ".tz") pm.connectAttr(ctrl + ".offsetRotate", offset + ".r") pm.connectAttr(ctrl + ".displayCtrler", dispGrp + ".v") # Lock and Hide unused attr attrList = [ "_ry.tx", "_ry.ty", "_ry.tz", "_ry.rx", "_ry.rz", "_ry.sx", "_ry.sy", "_ry.sz", "_ry.v", "_rx.tx", "_rx.ty", "_rx.tz", "_rx.ry", "_rx.rz", "_rx.sx", "_rx.sy", "_rx.sz", "_rx.v", "_rz.tx", "_rz.ty", "_rz.tz", "_rz.rx", "_rz.ry", "_rz.sx", "_rz.sy", "_rz.sz", "_rz.v", "_tz.tx", "_tz.ty", "_tz.rx", "_tz.ry", "_tz.rz", "_tz.sx", "_tz.sy", "_tz.sz", "_tz.v", "_offsetTx.ty", "_offsetTx.tz", "_offsetTx.rx", "_offsetTx.ry", "_offsetTx.rz", "_offsetTx.sx", "_offsetTx.sy", "_offsetTx.sz", "_offsetTx.v", "_offsetTy.tx", "_offsetTy.tz", "_offsetTy.rx", "_offsetTy.ry", "_offsetTy.rz", "_offsetTy.sx", "_offsetTy.sy", "_offsetTy.sz", "_offsetTy.v", "_offsetTz.tx", "_offsetTz.ty", "_offsetTz.rx", "_offsetTz.ry", "_offsetTz.rz", "_offsetTz.sx", "_offsetTz.sy", "_offsetTz.sz", "_offsetTz.v", "_offset.sx", "_offset.sy", "_offset.sz", "_offset.v", "_Ctrl.sx", "_Ctrl.sy", "_Ctrl.sz" ] for attr in attrList: pm.setAttr(name + attr, lock=True, channelBox=False, keyable=False) pm.setAttr(cameraShape + ".orthographic", lock=False, channelBox=False, keyable=True) pm.setAttr(cameraShape + ".orthographicWidth", lock=False, channelBox=False, keyable=True) # Constraint camera const = pm.parentConstraint(constraint, self.camera, n=name + '_parentConstraint') pm.setAttr(const + ".nds", lock=True, channelBox=False, keyable=False) pm.setAttr(const + ".int", lock=True, channelBox=False, keyable=False) pm.setAttr(const + ".w0", lock=True, channelBox=False, keyable=False) pm.parent(const, ctrl) # Add and Connect message attr = "camera" nodes = [self.camera, ctrl] for node in nodes: if node.hasAttr(attr): node.deleteAttr(attr) pm.addAttr(node, ln=attr, multi=1, attributeType="message", indexMatters=False) for node in nodes: for i in range(0, 2): pm.connectAttr('{}.message'.format(nodes[i].name()), '{}.{}[{}]'.format(node.name(), attr, str(i)), f=1) # Return self.ctrl = ctrl uitConvertsion = self.ctrl.outputs(type="unitConversion") for uit in uitConvertsion: pm.rename(uit.name(), name + '_' + uit.name()) del self.extNode[:] self.extNode.extend([ constraint, offset, shakeTransform, offsetTz, offsetTy, offsetTx, tz, rz, rx, ry, ctrl ]) self.extNode.extend(dispNodeList) self.extNode.extend(uitConvertsion) pm.select(self.ctrl, r=1) return ctrl
def setup_motion_path(self): setup_name = self.get_setup_name() path_name = self.get_path_name() sample_obj = self.get_sample_objects() duplicate_flag = self.get_duplicate_flag() placement_type = self.get_placement_type() division_count = self.get_division_count() if setup_name == self.INVALID_INPUT_FAIL: pm.displayError("Invalid Input Entered for setup name") return None if path_name == self.INVALID_INPUT_FAIL: pm.displayError("Invalid Input Entered for path name") return None if path_name == self.NO_OBJECT_FAIL: pm.displayError("path Curve does not exist") return None if path_name == self.DATA_TYPE_FAIL: pm.displayError("Path can be only Nurb Curves") return None if division_count == self.INVALID_INPUT_FAIL: pm.displayError("Invalid Input Entered for divisions") return None if division_count == self.DATA_TYPE_FAIL: pm.displayError("Divisions can take only integer values") return None if sample_obj == self.NO_OBJECT_FAIL: pm.displayError("Sample Object not found") return None obj_list = [] path_anim_list = [] sel_objs = pm.ls(selection=True) if duplicate_flag: path_name = self.get_duplicate_path(path_crv=path_name) path_name = pm.rename(path_name, setup_name + "_path_CRV") if placement_type == "uniform": obj_list, path_anim_list = self.uniform_distribution( name=setup_name, path=path_name, sample=sample_obj, divisions=division_count) else: if not sel_objs: pm.displayError("No Objects selected") for obj in sel_objs: if not pm.objExists(obj): pm.displayWarning(str(obj), "does not exist") return None obj_list, path_anim_list = self.at_selection( name=setup_name, path=path_name, sample=sample_obj, selection_list=sel_objs) loc_pos = CustomScripts.midPos(selected_items=path_name) loc = pm.spaceLocator(name=setup_name + "_up_loc") pm.xform(loc, translation=loc_pos) control_crv = pm.circle(name=setup_name + "CTRL", normalX=1, normalY=0, normalZ=0) pm.xform(control_crv[0], translation=loc_pos, worldSpace=True) pm.select(clear=True) # add run and speed attributes on parent nurb curve pm.addAttr(control_crv[0], longName="run", attributeType="float", keyable=True) pm.addAttr(control_crv[0], longName="speed", attributeType="float", keyable=True, minValue=0.0, defaultValue=0.5) # edit the existing motion path to assign up locator for mtPth in path_anim_list: pm.pathAnimation(mtPth, edit=True, worldUpType="object", worldUpObject=loc) # parent the setup under the parent nurb curve pm.parent(path_name, control_crv[0]) pm.parent(loc, control_crv[0]) pm.select(clear=True) gp = pm.group(name=setup_name + "GP") pm.xform(gp, translation=loc_pos) pm.select(clear=True) obj_gp = pm.group(obj_list, name=setup_name + "object_GP") pm.parent(control_crv[0], gp) pm.parent(obj_gp, gp) # call to create expression function self.createTreadExpression(mtnPth=path_anim_list, runAttr=str(control_crv[0]) + ".run", speedAttr=str(control_crv[0]) + ".speed", exp_nm=setup_name) return None
def ckFidgetInit(): """ ckFidgetInit() description: this function should initialize ckFidget it should check for existing persistent data and create a new node if none exists then it creates the interface inputs: None outputs: initializes ckFidget """ try: print "checking for persistent fidget data" pm.select("ckFidget_GRP") isFidget = pm.getAttr("ckFidget_GRP.ckIsFidget") if isFidget == True: print "Data Found!" pm.setAttr("ckFidget_GRP.bumpBy", False) except: print "data not found initializing new ckFidget instance" pm.group(empty=True, name="ckFidget_GRP") pm.addAttr( longName="ckIsFidget", attributeType='bool', keyable=False ) pm.setAttr("ckFidget_GRP.ckIsFidget", True) pm.addAttr( longName="bumpBy", attributeType='bool', keyable=False ) pm.setAttr("ckFidget_GRP.bumpBy", False) pm.addAttr( longName="ckFidgetBump", attributeType='float', keyable=False, defaultValue=0.1 ) pm.addAttr( longName="numSaves", attributeType="short", keyable=False, defaultValue=0 ) print "here is where I should ask about starting a new fidget" # should pop up a dialog and ask the name of the new fidget pm.addAttr( longName="ckFidgetList", dataType='string', keyable=False ) pm.addAttr( longName="ckFidgetSav", dataType='string', keyable=False ) pm.setAttr( "ckFidget_GRP.ckFidgetList","" ) pm.setAttr( "ckFidget_GRP.ckFidgetSav","" ) pm.select( clear = True ) ckFidgetWin()
def createTread(**kwargs): # get inputs divisions = kwargs.get("no_of_joints", 0) tread_name = kwargs.get("tr_name", "Tread") path_crv = kwargs.get("path_crv", None) # duplicate the existing curve to use for tread creation path_crv = str(pm.duplicate(path_crv, name=str(tread_name) + "PathCrv")[0]) pm.xform(path_crv, centerPivots=True) count = 0 part = float(1) / float(divisions) init = 0 path_anim_list = [] jnt_lst = [] # create joints and place them on curve using motion path at equal distance while count < divisions: pm.select(clear=True) jnt = pm.joint() jnt_lst.append(jnt) pathanim = pm.pathAnimation(jnt, curve=path_crv, fractionMode=True, follow=True, followAxis="x", worldUpType="vector", worldUpVector=(0, 1, 0)) path_anim_list.append(pathanim) pm.setAttr(str(pathanim) + ".uValue", init) pm.disconnectAttr(str(pathanim) + ".u") init += part count += 1 # obtain the midpoint of all joints to create an up locator and position it at midpoint #loc_pos = midPos(selected_items = jnt_lst) #loc_pos = pm.xform(path_crv, query=True, translation=True, worldSpace=True) loc_pos = midPosVec(objects=jnt_lst) loc = pm.spaceLocator(name=tread_name + "_up_loc") pm.xform(loc, translation=loc_pos) # create a nurb circle to act as parent controller control_crv = pm.circle(name=tread_name + "CTRL", normalX=1, normalY=0, normalZ=0) pm.xform(control_crv, translation=loc_pos) pm.select(clear=True) # add unr and speed attributes on parent nurb curve pm.addAttr(control_crv, longName="run", attributeType="float", keyable=True) pm.addAttr(control_crv, longName="speed", attributeType="float", keyable=True, minValue=0.0, defaultValue=0.5) #edit the existing motion path to assign up locator for mtPth in path_anim_list: pm.pathAnimation(mtPth, edit=True, worldUpType="object", worldUpObject=loc) #parent the setup under the parent nurb curve pm.parent(path_crv, control_crv) pm.parent(loc, control_crv) pm.select(clear=True) gp = pm.group(name=tread_name + "GP") pm.select(clear=True) jnt_gp = pm.group(jnt_lst, name=tread_name + "JNTGP") pm.xform(gp, translation=loc_pos) pm.parent(control_crv, gp) pm.parent(jnt_gp, gp) # call to create expression function createTreadExpression(mtnPth=path_anim_list, runAttr=str(control_crv[0]) + ".run", speedAttr=str(control_crv[0]) + ".speed", exp_nm=tread_name) return None