def on_btn_FixSkinBsEnd_clicked(self, clicked=None): if clicked == None:return selectIndexes = self.listView_attributeList.selectedIndexes() if len(selectIndexes) == 0:return selectAttr = self.__AttributeModel.data(selectIndexes[0], QtCore.Qt.DisplayRole) if not uiTool.warning('BlendShape\'s shape on attribute "%s" will be changed,\nand it can\'t to undo, \ncontinue? ?'%selectAttr):return openCloseDeformer(self.__baseModel, 0, ('skinCluster')) newSculpModel = cvShapeInverterCmds.invert(self.__baseModel, self.__sculpmodel, self.progressBar) mc.delete(newSculpModel, ch=True) openCloseDeformer(self.__baseModel, 1, ('skinCluster')) if mc.objExists(selectAttr): mc.blendShape(newSculpModel, selectAttr, w=((0, 1))) mc.delete(selectAttr, ch=True) mc.delete(newSculpModel) else: shape = mc.listRelatives(newSculpModel, s=True, path=True)[0] weightID = self.__AttributeDT2.get(selectAttr, None) TGTattr = self.__IGTAttributeDT.get(weightID, None) mc.connectAttr('%s.worldMesh[0]'%shape, '%s.%s'%(self.__blendShape, TGTattr), f=True) mc.rename(newSculpModel, selectAttr) mc.delete(self.__sculpmodel) mc.delete(self.__tempmodel)
def updateColor(self, mID, colorname): """ Update the color of the Maya's Mesh Node associated with a this StrandItem, this is done by creating a shadingNode for each color or connecting the Mesh Mode to an existing shadingNode if one exists for a given color. """ m = Mom() meshName = "%s%s" % (m.helixMeshName, mID) color = QColor(colorname) colorval = "%d_%d_%d" % (color.red(), color.green(), color.blue()) shaderName = "%s%d_%d_%d" % (m.helixShaderName, color.red(), color.green(), color.blue()) if not cmds.objExists(shaderName): # Shader does not exist create one cmds.shadingNode('lambert', asShader=True, name=shaderName) cmds.sets(n="%sSG" % shaderName, r=True, nss=True, em=True) cmds.connectAttr("%s.outColor" % shaderName, "%sSG.surfaceShader" % shaderName) cmds.setAttr("%s.color" % shaderName, color.redF(), color.greenF(), color.blueF(), type="double3") cmds.sets(meshName, forceElement="%sSG" % shaderName) else: #shader exist connect cmds.sets(meshName, forceElement="%sSG" % shaderName)
def __createFrustumNode( mainCam, parent, baseName ): """ Private method to this module. Create a display frustum node under the given parent. Make the default connections between the master camera and the frustum Remove some of the channel box attributes that we do not want to show up in the channel box. """ frustum = cmds.createNode( 'stereoRigFrustum', name=baseName, parent=parent ) for attr in [ 'localPositionX', 'localPositionY', 'localPositionZ', 'localScaleX', 'localScaleY', 'localScaleZ' ] : cmds.setAttr( frustum + '.' + attr, channelBox=False ) for attr in ['displayNearClip', 'displayFarClip', 'displayFrustum', 'zeroParallaxPlane', 'zeroParallaxTransparency', 'zeroParallaxColor', 'safeViewingVolume', 'safeVolumeTransparency', 'safeVolumeColor', 'safeStereo', 'zeroParallax' ] : cmds.connectAttr( mainCam+'.'+attr, frustum+'.'+attr ) return frustum
def createJointOnCurveByLength( multRate, distNode=True ): sels = cmds.ls( sl=1 ) curveSetInst = CreateJointOnCurveSet() curveInfo = cmds.createNode( 'curveInfo' ) returnTargets = [] for sel in sels: selCurve = cmds.listRelatives( sel, s=1 ) if not selCurve: continue selCurve = selCurve[0] cmds.connectAttr( selCurve+'.local', curveInfo+'.inputCurve', f=1 ) length = cmds.getAttr( curveInfo+'.arcLength' ) curveSetInst.setJointNum( int( length * multRate ) ) curveSetInst.setCurve( selCurve ) joints = curveSetInst.create( distNode ) returnTargets.append( joints ) return returnTargets
def switch(node,attr,value=0,inputNames=list(),inputValues=list()): ''' :param node: :param attr: :param value: :param inputName: :param inputValues: :return: ''' attrName = "{0}.{1}".format(node,attr) choiceName = "{0}_{1}_switch".format(node,attr) cmds.createNode("choice",name=choiceName) cmds.addAttr(node,ln=attr,at="enum",en=":".join(inputNames),dv=value,keyable=True) for i in range(len(inputValues)): choiceAttr = "output{0}".format(i) cmds.addAttr(choiceName,ln=choiceAttr,at="double3") cmds.addAttr(choiceName,ln="{0}x".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][0]) cmds.addAttr(choiceName,ln="{0}y".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][1]) cmds.addAttr(choiceName,ln="{0}z".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][2]) cmds.connectAttr("{0}.{1}".format(choiceName,choiceAttr),"{0}.input[{1}]".format(choiceName,i)) cmds.connectAttr(attrName,"{0}.selector".format(choiceName),f=True) return "{0}.output".format(choiceName)
def connectBind(self): #Create opposite node to blend blendOpposite = rc.create1MinusNode( "%s.%s" %(self.m_blendControl, self.m_blendAttr), "%s_IKFKBlendOpp_CTRL" %(self.m_name) ) for i in range(len(self.m_bindJoints)): const1 = cmds.parentConstraint( self.m_ikJoints[i], self.m_bindJoints[i], st = ["x", "y", "z"] )[0] const2 = cmds.parentConstraint( self.m_fkJoints[i], self.m_bindJoints[i], st = ["x", "y", "z"] )[0] cmds.connectAttr( blendOpposite, "%s.blendParent2" %(self.m_bindJoints[i]) ) # Change to quarternion pairBlend = cmds.listConnections( "%s.constraintRotateX" %(const1), d=1 )[0] cmds.setAttr("%s.rotInterpolation" %(pairBlend), 1)
def nucleus_(self, name = ''): nucleus = cmds.createNode('nucleus') if name: nucleus = cmds.rename(nucleus, name) cmds.connectAttr('time1.outTime', '%s.currentTime' % nucleus) return nucleus
def connect(self, plug): if plug is str: plug = Plug.fromName(plug) if plug.isArray: mc.connectAttr(self.name, plug.name, nextAvailable = True) else: mc.connectAttr(self.name, plug.name)
def _publish_gpu_for_item(self, item, output, work_template, primary_publish_path, sg_task, comment, thumbnail_path, progress_cb): """ Export a gpu cache for the specified item and publish it to Shotgun. """ group_name = item["name"].strip("|") debug(app = None, method = '_publish_gpu_for_item', message = 'group_name: %s' % group_name, verbose = False) tank_type = output["tank_type"] publish_template = output["publish_template"] # get the current scene path and extract fields from it using the work template: scene_path = os.path.abspath(cmds.file(query=True, sn= True)) fields = work_template.get_fields(scene_path) publish_version = fields["version"] # update fields with the group name: fields["grp_name"] = group_name ## create the publish path by applying the fields with the publish template: publish_path = publish_template.apply_fields(fields) #'@asset_root/publish/gpu/{name}[_{grp_name}].v{version}.abc' gpuFileName = os.path.splitext(publish_path)[0].split('\\')[-1] fileDir = '/'.join(publish_path.split('\\')[0:-1]) debug(app = None, method = '_publish_gpu_for_item', message = 'gpuFileName: %s' % gpuFileName, verbose = False) ## Now fix the shaders shd.fixDGForGPU() if cmds.objExists('CORE_ARCHIVES_hrc'): cmds.setAttr('CORE_ARCHIVES_hrc.visiblity', 0) if cmds.objExists('ROOT_ARCHIVES_DNT_hrc'): cmds.setAttr('ROOT_ARCHIVES_DNT_hrc.visiblity', 0) ## build and execute the gpu cache export command for this item: try: print '=====================' print 'Exporting gpu now to %s\%s' % (fileDir, gpuFileName) #PUT THE FILE EXPORT COMMAND HERE cmds.select(clear = True) for geo in cmds.listRelatives(group_name, children = True): if 'geo_hrc' in geo: geoGroup = str(group_name) debug(app = None, method = '_publish_gpu_for_item', message = 'geoGroup: %s' % geoGroup, verbose = False) cmds.select(geoGroup) debug(app = None, method = '_publish_gpu_for_item', message = 'geoGroup: %s' % geoGroup, verbose = False) debug(app = None, method = '_publish_gpu_for_item', message = "gpuCache -startTime 1 -endTime 1 -optimize -optimizationThreshold 40000 -directory \"%s\" -fileName %s %s;" % (fileDir, gpuFileName, geoGroup), verbose = False) mel.eval("gpuCache -startTime 1 -endTime 1 -optimize -optimizationThreshold 40000 -directory \"%s\" -fileName %s %s;" % (fileDir, gpuFileName, geoGroup)) print 'Finished gpu export...' print '=====================' if cmds.objExists('dgSHD'): ## Now reconnect the FileIn nodes for key, var in filesDict.items(): cmds.connectAttr('%s.outColor' % key, '%s.color' % var) except Exception, e: raise TankError("Failed to export gpu cache file")
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 _bind_joint_setup(self): """Skinweight the nurbs curve which affects the nurbs surface.""" skn = cmds.skinCluster(self.nrbcurve, self.joints, tsb=True, nw=1, sm=0, bm=0, mi=1, dr=10)[0] bindpose = cmds.listConnections('%s.bindPose' % skn)[0] cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % skn) cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % bindpose)
def install_custom(self, joints, moduleGrp, moduleContainer): joint = joints[1] name = "globalControl" controlObjectInstance = controlObject.ControlObject() globalControlInfo = controlObjectInstance.create(name, "cubeLocator.ma", self, lod=1, translation=True, rotation=True, globalScale=True, spaceSwitching=True) globalControl = globalControlInfo[0] globalControl_rootParent = globalControlInfo[1] # Position and orient control object pos = cmds.xform(joint, q=True, worldSpace=True, translation=True) orient = cmds.xform(joint, q=True, worldSpace=True, rotation=True) cmds.xform(globalControl, worldSpace=True, absolute=True, translation=pos) cmds.xform(globalControl, worldSpace=True, absolute=True, rotation=orient) """ Try freezing transforms """ #cmds.makeIdentity(globalControl, apply=True, t=True, r=False, s=False) cmds.parent(globalControl_rootParent, moduleGrp, absolute=True) cmds.connectAttr(joint+".rotateOrder", globalControl+".rotateOrder") parentConstraint = cmds.parentConstraint(globalControl, joint, maintainOffset=False, n=joint+"_parentConstraint")[0] scaleConstraint = cmds.scaleConstraint(globalControl, joint, maintainOffset=False, n=joint+"_scaleConstraint")[0] utils.addNodeToContainer(moduleContainer, [parentConstraint, scaleConstraint])
def setCage(self, node): meshes = pm.selected( type="transform" ) if not meshes: return shape=meshes[-1].getShapes()[0] cmds.connectAttr(shape+".worldMesh[0]", node.name()+".cageMesh") self.updateUI()
def createDistanceNodeBetweenPosInfoNodes (node1,node2): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Creates a distance node between two position info nodes ARGUMENTS: node1(string) node2(string) RETURNS: returnList[0] - distance object returnList[1] - shape node returnList[2] - shape node distance attribute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ returnList =[] distShapeBuffer = mc.createNode ('distanceDimShape') distBuffer = (mc.listRelatives (distShapeBuffer,parent=True)) mc.connectAttr ((node1+'.position'),(distShapeBuffer+'.startPoint')) mc.connectAttr ((node2+'.position'),(distShapeBuffer+'.endPoint')) distanceObj = mc.rename (distBuffer, (node1+'_to_'+node2+'_distNode') ) newDistShapeBuffer = (mc.listRelatives (distanceObj,shapes=True)) returnList.append (distanceObj) returnList.append (newDistShapeBuffer[0]) returnList.append (newDistShapeBuffer[0]+'.distance') return returnList
def connect( self, obj, slot=None ): ''' performs the actual connection of an object to a connect slot ''' if not cmd.objExists(obj): return -1 #if the user is trying to connect the trigger to itself, return zero which is the reserved slot for the trigger if apiExtensions.cmpNodes( self.obj, obj ): return 0 if slot is None: slot = self.nextSlot() if slot <= 0: return 0 #make sure the connect isn't already connected - if it is, return the slot number existingSlots = self.isConnected(obj) if existingSlots: return self.getConnectSlots(obj)[0] conPrefix = 'zooTrig' prefixSize = len(conPrefix) slotPath = "%s.%s%d" % (self.obj, conPrefix, slot) if not objExists( slotPath ): cmd.addAttr(self.obj,ln= "%s%d" % (conPrefix, slot), at='message') cmd.connectAttr( "%s.msg" % obj, slotPath, f=True ) self.cacheConnect( slot ) return slot
def creatSphere(*args): circleSel = mc.ls(sl=1)[0] radiusCircle = mc.circle(circleSel, q=1, r=1) radiusSpere = radiusCircle*.75 particleSphere = mc.polySphere(n='%s_Sphere'%circleSel, r=radiusSpere, sx=float(radiusSpere), sy=float(radiusSpere), ax=[0, 1, 0])[0] mc.parentConstraint(circleSel, particleSphere, mo=0, w=1) #mc.parent(particleSphere, circleSel) mc.setAttr('%s.tx'%particleSphere, 0) mc.setAttr('%s.ty'%particleSphere, 0) mc.setAttr('%s.tz'%particleSphere, 0) mc.setAttr('%s.rx'%particleSphere, 0) mc.setAttr('%s.ry'%particleSphere, 0) mc.setAttr('%s.rz'%particleSphere, 0) mc.setAttr('%s.v'%particleSphere, 0) mc.select(particleSphere, r=1) mc.emitter(type='surface', r=4, dx=1, dy=0, dz=0, n='%s_emitter'%circleSel ) mc.particle( n='%s_Particles'%circleSel ) mc.connectDynamic( '%s_Particles'%circleSel, em='%s_emitter'%circleSel ) particlesShape = mc.listRelatives('%s_Particles'%circleSel, s=1)[0] mc.setAttr('%s.lifespanMode'%particlesShape, 1) mc.setAttr('%s.lifespan'%particlesShape, 0.4) mc.setAttr('%s.startFrame'%particlesShape, 1001) mc.connectControl( 'numText', '%s.rate'%('%s_emitter'%circleSel) ) mc.shadingNode('blinn', n='%s_blinn'%circleSel, asShader=1) mc.sets( n='%s_blinnSG'%circleSel, renderable=True, noSurfaceShader=True, empty=1) mc.connectAttr('%s.outColor'%('%s_blinn'%circleSel), '%s.surfaceShader'%('%s_blinnSG'%circleSel)) mc.connectControl( 'myColorIndex', '%s.color'%('%s_blinn'%circleSel) ) mc.connectControl( 'lifeText', '%s.lifespan'%particlesShape ) mc.sets('%s_Particles'%circleSel, e=1, forceElement='%s'%('%s_blinnSG'%circleSel))
def returnClosestUV (targetObject,surface): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Pass target object and surface into it and return the closest UV coordinates ARGUMENTS: targetObject(string) surface(string) RETURNS: UV(string) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ """ pass target object and surface into it and return the closest UV coordinates""" UVs = [] """ make the node """ tmpNode = mc.createNode ('closestPointOnSurface') """ to account for target objects in heirarchies """ tmpObj = rigging.locMeObjectStandAlone(targetObject) mc.connectAttr ((tmpObj+'.translate'),(tmpNode+'.inPosition')) mc.connectAttr ((surface+'.worldSpace'),(tmpNode+'.inputSurface')) UVs.append (mc.getAttr (tmpNode+'.u')) UVs.append (mc.getAttr (tmpNode+'.v')) mc.delete (tmpNode) mc.delete (tmpObj) return UVs
def __init__( self, fkik_snap_set ): cmds.select( cl = True ) self.get_globals() for obj in cmds.sets( fkik_snap_set, q = True ): controller = DAG_Node( obj ) obj_snap_attr = '{0}.{1}'.format( controller.name(), self.snap_parent_str ) if cmds.objExists( obj_snap_attr ): obj_snap = cmds.listConnections( obj_snap_attr ) if obj_snap: obj_snap = obj_snap[0] snap_grp = DAG_Node( cmds.group( n = '{0}_Snap_Grp'.format( obj.split( '|' )[-1] ), em = True ) ) snap_grp.set_parent( controller.parent() ) obj_tra = cmds.xform( controller.name(), ws = True, rp = True, q = True ) cmds.xform( snap_grp.name(), ws = True, t = obj_tra ) obj_rot = cmds.xform( controller.name(), ws = True, ro = True, q = True ) cmds.xform( snap_grp.name(), ws = True, ro = obj_rot ) cmds.makeIdentity( snap_grp.name(), a = True, t = True, r = True, s = True ) cmds.parentConstraint( obj_snap, snap_grp.name(), mo = True ) snap_grp_attr = Maya_Util().add_attr( snap_grp.name(), self.snap_parent_str, 'message' ) cmds.connectAttr( snap_grp_attr, obj_snap_attr, force = True ) cmds.select( cl = True )
def removeLayTex(self, argsv): # get shapes of selection: args = cmds.ls(sl=1) shapesInSel = cmds.ls(dag=1,o=1,s=1,sl=1) shapeIndex = 0 for arg in args : # get shading groups from shapes: shadingGrps = cmds.listConnections(shapesInSel[shapeIndex],type='shadingEngine') # get the shaders: shaders = cmds.ls(cmds.listConnections(shadingGrps),materials=1) shader = shaders[0] #print cmds.listRelatives (p=True, arg) layeredTex = cmds.listConnections(shader, type='layeredTexture') layeredTex = layeredTex[0] if (not layeredTex == None): fileTex = cmds.listConnections(layeredTex, type='file') fileTex = fileTex[0] if (not fileTex == None): cmds.delete(layeredTex) print 'Connecting ' + shader + '.color to ' + fileTex + '.outColor' cmds.connectAttr(fileTex+'.outColor', shader+'.color', f=1) else: print ('Object ' + arg + ' does not have a file texture attached, skipping') else: print ('Object ' + arg + ' does not have a layered texture attached, skipping') shapeIndex += 1
def connectCommand( uiInstance ): sels = cmds.ls( sl=1 ) selChannels = cmds.channelBox( 'mainChannelBox', q=1, sma=1 ) numItems = uiInstance.layout.count() animNode = cmds.createNode( 'animCurveUU' ) for i in range( 1, numItems-1 ): targetWidget = uiInstance.layout.itemAt( i ).widget() key = targetWidget.lineEdit_key.text() value = targetWidget.lineEdit_value.text() cmds.setKeyframe( animNode, f=float(key), v=float(value) ) cmds.keyTangent( animNode, f=(float(key),float(key)), itt='linear', ott = 'linear' ) if sels and selChannels: cmds.connectAttr( sels[0] + '.' + selChannels[0], animNode + '.input' ) addString = '' if float(key) > 0: addString = 'positive' else: addString = 'negative' animNode = cmds.rename( animNode, selChannels[0] + '_' + addString + '_from_' + sels[0] ) cmds.select( animNode )
def add_snap_obj( self, *args ): snap_obj = cmds.ls( sl = True ) main_obj = cmds.textScrollList( self.object_name_scroll, si = True, q = True )[0] if snap_obj: snap_obj = snap_obj[0] snap_attr = '{0}.{1}'.format( snap_obj, self.snap_child_str ) if not cmds.objExists( snap_attr ): snap_attr = Maya_Util().add_attr( snap_obj, self.snap_child_str, 'message' ) try: cmds.connectAttr( snap_attr, '{0}.{1}'.format( main_obj, self.snap_parent_str ), force = True ) except: pass order_number = cmds.textScrollList( self.object_order_scroll, si = True, q = True )[0] obj_name = cmds.textScrollList( self.object_name_scroll, si = True, q = True )[0] self.remove_set_connections( cmds.textScrollList( self.object_name_scroll, selectIndexedItem = True, q = True ) ) cmds.textScrollList( self.object_order_scroll, append = order_number, e = True ) cmds.textScrollList( self.object_name_scroll, append = obj_name, e = True ) cmds.textScrollList( self.object_connect_scroll, append = self.arrow_str, e = True ) cmds.textScrollList( self.object_snap_scroll, append = snap_obj, e = True ) self.obj_list_select( index = cmds.textScrollList( self.object_order_scroll, numberOfItems = True, q = True ) ) else: OpenMaya.MGlobal.displayError( "There are no objects selected!" )
def connectLoresVis(toggleAttr="allTransA_ctrl.loGeoVis"): """ Connect lores geometry visibility to the specified visibility toggle attribute @param toggleAttr: Visibility toggle attribute @type toggleAttr: str """ # Check visibility toggle attribute if not mc.objExists(toggleAttr): raise Exception('Visibility toggle attribute "' + toggleAttr + '" does not exist!') # Get all joint list jointList = mc.ls(type="joint") if not jointList: return # Iterate over all joints for joint in jointList: # Get all joint mesh shapes allShapes = mc.listRelatives(joint, s=True, pa=True) if not allShapes: continue meshShapes = mc.ls(allShapes, type="mesh") if not meshShapes: continue # Connect mesh shape visibility to vis toggle attr for meshShape in meshShapes: mc.connectAttr(toggleAttr, meshShape + ".v", f=True)
def BindSkeletons(source, dest, method='connect'): ''' From 2 given root joints search through each hierarchy for child joints, match them based on node name, then connect their trans/rots directly, or parentConstrain them. Again cmds for speed ''' sourceJoints = cmds.listRelatives(source, ad=True, f=True, type='joint') destJoints = cmds.listRelatives(dest, ad=True, f=True, type='joint') if cmds.nodeType(source) == 'joint': sourceJoints.append(source) if cmds.nodeType(dest) == 'joint': destJoints.append(dest) attrs = ['rotateX', 'rotateY', 'rotateZ', 'translateX', 'translateY', 'translateZ'] for sJnt, dJnt in MatchGivenHierarchys(sourceJoints, destJoints): if method == 'connect': for attr in attrs: try: cmds.connectAttr('%s.%s' % (sJnt, attr), '%s.%s' % (dJnt, attr), f=True) except: pass elif method == 'constrain': try: cmds.parentConstraint(sJnt, dJnt, mo=True) except: pass
def ShapeInverterCmdold(base=None, corrective=None, name=None): mc.undoInfo(openChunk=True) if not base or not corrective: sel = mc.ls(sl=True) base, corrective = sel shapes = mc.listRelatives(base, children=True, shapes=True) for s in shapes: if mc.getAttr("%s.intermediateObject" % s) and mc.listConnections("%s.worldMesh" % s, source=False): origMesh = s break deformed = mc.polyPlane(ch=False)[0] mc.connectAttr("%s.worldMesh" % origMesh, "%s.inMesh" % deformed) mc.setAttr("%s.intermediateObject" % origMesh, 0) mc.delete(deformed, ch=True) mc.setAttr("%s.intermediateObject" % origMesh, 1) if not name: name = "%s_inverted#" % corrective invertedShape = duplicateMesh(base, name=name) deformer = mc.deformer(invertedShape, type="ShapeInverter")[0] mc.ShapeInverterCmd(baseMesh=base, invertedShape=invertedShape, ShapeInverterdeformer=deformer, origMesh=deformed) # correctiveShape = duplicateMesh(base,name=corrective+"_corrective#") # mc.connectAttr('%s.outMesh' % getShape(correctiveShape), '%s.correctiveMesh' % deformer) # transferMesh(corrective,[correctiveShape]) mc.connectAttr("%s.outMesh" % getShape(corrective), "%s.correctiveMesh" % deformer) mc.setAttr("%s.activate" % deformer, True) mc.delete(deformed) bdingBx = mc.polyEvaluate(corrective, boundingBox=True) xDifVal = bdingBx[0][1] - bdingBx[0][0] # mc.move(xDifVal*1.10,correctiveShape,r=True,moveX=True) mc.move(xDifVal * 2.20, invertedShape, r=True, moveX=True) mc.undoInfo(closeChunk=True) return invertedShape # ,correctiveShape
def connectMovedDriverToFixedNode(self): targetMesh = self._targetMesh node = getBlendAndFixedShapeNode( targetMesh ) attrs = [] for driver, attr in self._driverAndAttr: value0 = cmds.getAttr( driver+'.'+attr ) attrs.append( driver+'.'+attr ) self._connectIndices = [] self._connectWeights = [] for attr in attrs: blendAndFixedShapeCons = cmds.listConnections( attr, type='blendAndFixedShape' ) if not blendAndFixedShapeCons: targetIndex = fnc.getLastIndex( node+'.driverWeights' )+1 cmds.connectAttr( attr, node+'.driverWeights[%d]' % targetIndex ) self._connectIndices.append( targetIndex ) self._connectWeights.append( value0 ) continue if not node in blendAndFixedShapeCons: continue cons = cmds.listConnections( attr, p=1, c=1 ) targetAttr = cons[1] connectedIndex = int( targetAttr.split('[')[1].replace(']','' ) ) connectedValue = cmds.getAttr( cons[1] ) self._connectIndices.append( connectedIndex ) self._connectWeights.append( connectedValue )
def perform(**kwargs): sel = cmds.ls(sl=True) sel3=[] for s in sel: sel3+=cmds.xform(s,q=True, ws=True, t=True) pointset=[] for i in xrange(len(sel3)/3): pointset+=[Vector(sel3[i*3],sel3[i*3+1],sel3[i*3+2])] bbox = BBox() bbox.obbFromPointSet(pointset) t = Transform(bbox.axis[0],bbox.axis[1],bbox.axis[2]) t = t.transpose() z = t.getEuler() cube = cmds.createNode("polyCube") cubeShape = cmds.createNode("mesh") cubeTrans = cmds.listRelatives(cubeShape,p=True)[0] cmds.connectAttr(cube+".output",cubeShape+".inMesh") cmds.setAttr(cubeTrans+".tx",bbox.center[0]) cmds.setAttr(cubeTrans+".ty",bbox.center[1]) cmds.setAttr(cubeTrans+".tz",bbox.center[2]) cmds.setAttr(cubeTrans+".rz",degrees(z[2])) cmds.setAttr(cubeTrans+".ry",degrees(z[1])) cmds.setAttr(cubeTrans+".rx",degrees(z[0])) cmds.setAttr(cube+".width",bbox.max[0]-bbox.min[0]) cmds.setAttr(cube+".height",bbox.max[1]-bbox.min[1]) cmds.setAttr(cube+".depth",bbox.max[2]-bbox.min[2]) cmds.sets(e=True,forceElement="initialShadingGroup") cmds.select(sel)
def ImportCustomTexture(name): os.system("cd ~/maya/2014-x64/scripts; python texture.py") file = '/usr/tmp/texture.jpg' #create a shader shader=cmds.shadingNode( "blinn", asShader=True ) #a file texture node shaderName = file_node=cmds.shadingNode( "file", asTexture=True ) print shaderName #attach file to node cmds.setAttr( '%s.fileTextureName' %file_node, file, type = "string") # a shading group shading_group= cmds.sets(renderable=True,noSurfaceShader=True,empty=True) #connect shader to sg surface shader cmds.connectAttr('%s.outColor' %shader ,'%s.surfaceShader' %shading_group) #connect file texture node to shader's color cmds.connectAttr('%s.outColor' %file_node, '%s.color' %shader) cmds.sets(name, edit=True, forceElement=shading_group)
def __setup_sculpt_shader(self): #--- this method setups the sculpt shader color #--- list all the shader names shader_list = ['sculptShaderGreen'] #--- check if shader exists, else create a new one for s in range(len(shader_list)): if cmds.objExists(shader_list[s]): #--- check which mesh is selected self.shader = shader_list[0] self.shader_set = shader_list[0] + '3SG' else: #--- create the lambert shader self.shader = cmds.shadingNode('lambert', asShader = True, name = shader_list[0]) self.shader_set = cmds.sets(self.shader, renderable = True, noSurfaceShader = True, empty = True, name = shader_list[0] + '3SG') cmds.connectAttr(self.shader + '.outColor', self.shader_set + '.surfaceShader', force = True) #--- change the color cmds.setAttr(self.shader + '.color', 0, 1, 1) #--- assign the shader to the sculpt_mesh cmds.sets(self.sculpt_mesh, forceElement = self.shader_set)
def _parentSurfaceFLCL(self, constrained_obj, geo, deleteCPOMS=1): """ Parents object to follicle at closest point on surface. Select child transform, then select mesh to hold parent follicle. """ cpos = pmc.createNode('closestPointOnSurface', n='cpos_flcl_' + geo) mc.connectAttr(pmc.listRelatives(geo, shapes=True, children=True)[0] + '.local', cpos + '.inputSurface') obj_mtx = pmc.xform(constrained_obj, q=True, m=True) pmc.setAttr(cpos + '.inPosition', [obj_mtx[12], obj_mtx[13], obj_mtx[14]]) flclShape = pmc.createNode('follicle', n='flclShape' + geo) flcl = pmc.listRelatives(flclShape, type='transform', parent=True) pmc.rename(flcl, 'flcl_' + geo + '_1') mc.connectAttr(flclShape + '.outRotate', flcl[0] + '.rotate') mc.connectAttr(flclShape + '.outTranslate', flcl[0] + '.translate') mc.connectAttr(geo + '.worldMatrix', flclShape + '.inputWorldMatrix') mc.connectAttr(geo + '.local', flclShape + '.inputSurface') mc.setAttr(flclShape + '.simulationMethod', 0) u = mc.getAttr(cpos + '.result.parameterU') v = mc.getAttr(cpos + '.result.parameterV') pmc.setAttr(flclShape + '.parameterU', u) pmc.setAttr(flclShape + '.parameterV', v) pmc.parent(constrained_obj, flcl) if deleteCPOMS == 1: pmc.delete(cpos) return flcl
def uiCmd_connectBindPreMatrix( *args ): selections = cmds.ls( sl=1 ) firsts = selections[:-1][::2] seconds = selections[:-1][1::2] last = selections[-1] for i in range( len( firsts ) ): first = firsts[i] second = seconds[i] cons = cmds.listConnections( first, type='skinCluster', d=1, s=0, c=1, p=1 ) outputs = cons[0::2] inputs = cons[1::2] for ii in range( len( outputs ) ): if inputs[ii].find( 'matrix' ) == -1: continue outputAttr = outputs[ii].replace( first, second ).replace( 'worldMatrix', 'worldInverseMatrix' ) inputAttr = inputs[ii].replace( 'matrix', 'bindPreMatrix' ) if inputAttr.find( last ) == -1: continue if not cmds.isConnected( outputAttr, inputAttr ): cmds.connectAttr( outputAttr, inputAttr, f=1 )
def dupeRig(dupeRig, pNameSearchField, pNameReplaceField): #The order in which these are assigned matters more than the first arguement searchForField = cmds.textField(nameSearchField, query=True, text=True) replaceWithField = cmds.textField(nameReplaceField, query=True, text=True) print('dupeRig(), the searchForField is: ' + searchForField) print('dupeRig(), the replaceWithField is: ' + replaceWithField) objectType = cmds.objectType(globalRigToDupe) if (objectType != 'joint'): print('You must load a joint to duplicate') elif (objectType == 'joint'): originalRootName = globalRigToDupe[0] #Storing the original name of root print('dupeRig(), the originalRootName is : ' + str(originalRootName)) newObject = cmds.duplicate(globalRigToDupe[0], n='temp', rc=True) #the objects have to be renamed because there is nothing you can do with them until they have a different name from their originals cmds.parent(newObject[0], world = True) print('dupeRig(), the newObject is : ' + str(newObject)) reps = {searchForField: replaceWithField, 'SknNoWeight':'TARGET', '1': ''} nameForRootObject = renameObject(originalRootName, reps) #replacing the prefix print('dupeRig(), the newObject[0] is : ' + str(newObject[0])) duplicatedJoint = cmds.rename(newObject[0], nameForRootObject) #Changing the name back to something that makes sense print('dupeRig(), the duplicatedJoint is : ' + str(duplicatedJoint)) global globalTargetRig globalTargetRig = duplicatedJoint newSelection = cmds.listRelatives(duplicatedJoint, allDescendents=True)#creating a new list from the childern of the duplicated object, note we had to use the new name for the root object print('dupeRig(), the newSelection is: ' + str(newSelection)) #renaming the childen i=0 originalNameList = cmds.listRelatives(globalRigToDupe[0], allDescendents = True) print('dupeRig(), the originalNameList is: ' + str(originalNameList)) reps = {searchForField: replaceWithField, 'SknNoWeight': 'TARGET', 'SknGeo' : 'TARGET', 'Hair':'TARGET_Hair'} for eachObject in newSelection: objectName = originalNameList[i] # bind the returned text of the method # to a variable and print it newNameA = renameObject(objectName, reps) #print newNameAs print('dupeRig(), the object to rename is: ' + str(eachObject)) newName = cmds.rename(eachObject, newNameA) i= i+1 #parent constraining original rig to duplicated rig parentConstrainedRigList = cmds.listRelatives(globalRigToDupe[0], allDescendents = True, type = 'joint') print('dupRig(), globalTargetRig is: ' + str(globalTargetRig)) #at this point globalTargetRig is the root of the target rig targetRigList = cmds.listRelatives(globalTargetRig, allDescendents = True, type = 'joint') parentConstrainedRigList.insert(0, globalRigToDupe[0]) targetRigList.insert(0, globalTargetRig) print('dupeRig(), the parentConstrainedRigList[0] is: ' + str(parentConstrainedRigList[0])) print('dupeRig(), the targetRigList[0] is: ' + str(targetRigList[0])) #if cmds.attributeQuery(parentConstrainedRigList[0], node = 'RigFollow'): if (cmds.objExists(parentConstrainedRigList[0] + '.RigFollow')): print('dupeRig(), attribute RigFollow found') #cmds.select(parentConstrainedRigList[0]) cmds.deleteAttr(parentConstrainedRigList[0], attribute = 'RigFollow') cmds.addAttr(parentConstrainedRigList[0], attributeType = 'float', longName = 'RigFollow', hasMinValue = True, minValue = 0, maxValue = 1, defaultValue = 1, keyable = True) i=0 for eachJoint in parentConstrainedRigList: print('dupeRig(), the parentConstrainedRigList[i] is: ' + str(parentConstrainedRigList[i])) print('dupeRig(), the targetRigList[i] is: ' + str(targetRigList[i])) newParentConstraint = cmds.parentConstraint(targetRigList[i], parentConstrainedRigList[i]) newScaleConstraint = cmds.scaleConstraint(targetRigList[i], parentConstrainedRigList[i]) reps = {'|':''} targetRigString = renameObject(targetRigList[i], reps) #The following lines connect each parent and scale constraint to an attribute on the root joint that will dictate if the constraints have any effect cmds.connectAttr(str(parentConstrainedRigList[0]) + '.RigFollow', newParentConstraint[0].encode('utf8') + '.' + targetRigString + 'W0', force = True) cmds.connectAttr(str(parentConstrainedRigList[0]) + '.RigFollow', newScaleConstraint[0].encode('utf8') + '.' + targetRigString + 'W0', force = True) i=i+1 #This is all cleanup for the rig skeleton. It's just deleting all of the unused artifacts from the skin joint skeleton keepShapes = cmds.checkBox(keepShapesCheckBox, editable = True, query = True, value = True) if keepShapes == False: print('dupeRig(), keep shapes is false') shapeSelection = cmds.listRelatives(globalTargetRig, allDescendents = True, type = 'shape' ) #creating a list to select any unwanted shapes in the hierarchy #The reason why this is done as a loop is because if it throws an error you will know which shape to deal with for eachObject in shapeSelection: shapeTransform = cmds.listRelatives(eachObject, type = 'transform', parent = True ); #selecting the transforms of the shape nodes cmds.delete(shapeTransform) typeToPrune = 'transform' deleteFilteredObjects(globalTargetRig, typeToPrune) typeToPrune = 'ikEffector' deleteFilteredObjects(globalTargetRig, typeToPrune)
import maya.cmds as cmds def getMObject(target): mObject = OpenMaya.MObject() selList = OpenMaya.MSelectionList() selList.add(target) selList.getDependNode(0, mObject) return mObject sels = cmds.ls(sl=1) srcMesh = sels[0] otherMeshs = sels[1:] srcMeshShape = cmds.listRelatives(srcMesh, s=1, f=1)[0] for otherMesh in otherMeshs: otherMeshShape = cmds.listRelatives(otherMesh, s=1, f=1)[0] if cmds.isConnected(srcMeshShape + '.outMesh', otherMeshShape + '.inMesh'): continue cmds.connectAttr(srcMeshShape + '.outMesh', otherMeshShape + '.inMesh')
print('BUILD TEST __________________________ PREPARE SCENE') mc.file(pathBuildTest, i=True) mc.playbackOptions(min=0, max=400) inputObj = 'pCube1' outputObj = 'pCone1' print('BUILD TEST __________________________ LOAD NODE') mc.loadPlugin(pathNode) print('BUILD TEST __________________________ CREATE NODE') newNode = mc.createNode(nodeType) print('BUILD TEST __________________________ CONNECT IN') mc.connectAttr(inputObj + '.translateX', newNode + '.inValue') mc.connectAttr('time1.outTime', newNode + '.currentFrame') mc.connectAttr(inputObj + '.worldMatrix[0]', newNode + '.drawMatrix') print('BUILD TEST __________________________ CONNECT OUT') mc.connectAttr(newNode + '.outValue', outputObj + '.translateY') print('BUILD TEST __________________________ SET ATTR') print('BUILD TEST __________________________ DONE') mc.select(newNode) #LOAD DRAW print('BUILD TEST __________________________ PREPARE SCENE') camera = "persp" print('BUILD TEST __________________________ LOAD NODE')
def rotationStart(): global asT asT = cmds.playbackOptions(query=True, min=True) global aeT aeT = cmds.playbackOptions(query=True, max=True) resetLoopTime() global listObjects listObjects = cmds.ls(sl=True) if (len(listObjects) <= 1): print "\n||| Need to select two or more objects |||\n" else: #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed listFixed = listObjects[:] for i in range(len(listFixed)): listFixed[i] = listFixed[i].replace("|", "_") listFixed[i] = listFixed[i].replace(":", "_") #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName mainLayerName = "OVERLAPPY" if (cmds.objExists(mainLayerName)): print "\n||| OVERLAPPY start |||\n" else: cmds.animLayer(mainLayerName) print "\n||| OVERLAPPY start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range(len(listFixed)): if (i + 1 != len(listFixed)): global zeroLoc zeroLoc = listFixed[i] + "_base_loc" global aimLoc aimLoc = listFixed[i] + "_aim_loc" global tempLoc tempLoc = listFixed[i] + "_temp_loc" global tempAimLoc tempAimLoc = listFixed[i] + "_tempAim_loc" global tempPart tempPart = listFixed[i] + "_temp_part" global tempNucl tempNucl = "nucleus1" global partRtype partRtype = tempPart + "Shape.particleRenderType" global partRrad partRrad = tempPart + "Shape.radius" global partRsm partRsm = tempPart + "Shape.goalSmoothness" global partRwe partRwe = tempPart + "Shape.goalWeight[0]" global partNucl partNucl = tempNucl + ".timeScale" global nuclStart nuclStart = tempNucl + ".startFrame" if aimVectorReverse: rotAimVector = -1 else: rotAimVector = 1 #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.spaceLocator(n=zeroLoc) cmds.spaceLocator(n=aimLoc) cmds.spaceLocator(n=tempLoc) cmds.matchTransform(zeroLoc, listObjects[i], pos=True) cmds.matchTransform(tempLoc, listObjects[i + 1], pos=True) cmds.select(tempLoc, r=True) cmds.duplicate(n=tempAimLoc) cmds.select(listObjects[0], r=True) cmds.select(zeroLoc, add=True) cmds.parentConstraint(mo=True, w=1) cmds.select(aimLoc, r=True) cmds.select(zeroLoc, add=True) cmds.parent(r=True) cmds.select(listObjects[1], r=True) cmds.select(tempLoc, add=True) cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) aimPosName = tempLoc + ".translate" partCenter = tempPart + ".center" aimLocPos = tempAimLoc + ".translate" aimPos = cmds.getAttr(aimPosName) cmds.nParticle(p=aimPos, n=tempPart, c=1) cmds.goal(tempPart, w=0.5, utr=1, g=tempLoc) cmds.connectAttr(partCenter, aimLocPos, f=True) cmds.select(tempAimLoc, r=True) cmds.select(aimLoc, add=True) cmds.aimConstraint(w=1, aim=(0, rotAimVector, 0), u=(0, 1, 0), wut="vector", wu=(0, 1, 0), sk="y") #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmoothRot) cmds.setAttr(partRwe, goalWRot) cmds.setAttr(partNucl, timeScaleRot) cmds.setAttr(nuclStart, asT) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global minLoopTime minLoopTime = aeT * -3 global maxLoopTime maxLoopTime = aeT * 4 if (cycle): cmds.setAttr(nuclStart, minLoopTime) cmds.bakeResults(zeroLoc, t=(asT, aeT), sm=True, at=("translate", "rotate")) cmds.bakeResults(aimLoc, t=(minLoopTime, maxLoopTime), sm=True, at="rotate") cmds.delete(tempAimLoc, tempLoc, tempPart, tempNucl) zeroParent = zeroLoc + "_parentConstraint1" cmds.delete(zeroParent) setTimeToMin() cmds.select(aimLoc, r=True) cmds.select(listObjects[i], add=True) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.rotateX' attrY = listObjects[i] + '.rotateY' attrZ = listObjects[i] + '.rotateZ' lockX = cmds.getAttr(attrX, lock=True) lockY = cmds.getAttr(attrY, lock=True) lockZ = cmds.getAttr(attrZ, lock=True) if (lockX != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["y", "z"], w=1) if (lockY != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["x", "z"], w=1) if (lockZ != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["x", "y"], w=1) resetLoopTime() else: cmds.bakeResults(zeroLoc, t=(asT, aeT), sm=True, at=("translate", "rotate")) cmds.bakeResults(aimLoc, t=(asT, aeT), sm=True, at="rotate") cmds.delete(tempAimLoc, tempLoc, tempPart, tempNucl) zeroParent = zeroLoc + "_parentConstraint1" cmds.delete(zeroParent) resetLoopTime() cmds.select(aimLoc, r=True) cmds.select(listObjects[i], add=True) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.rotateX' attrY = listObjects[i] + '.rotateY' attrZ = listObjects[i] + '.rotateZ' lockX = cmds.getAttr(attrX, lock=True) lockY = cmds.getAttr(attrY, lock=True) lockZ = cmds.getAttr(attrZ, lock=True) if (lockX != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["y", "z"], w=1) if (lockY != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["x", "z"], w=1) if (lockZ != True): cmds.parentConstraint(mo=True, st=["x", "y", "z"], sr=["x", "y"], w=1) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "rotate_" layerName = layerBase + listFixed[i] layerComp = listFixed[i] + '_layer_{0}'.format("0") if (cmds.objExists(layerName)): cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="rotate") cmds.select(listObjects[i], r=True) if (cycleInfinity): cmds.setInfinity(pri="cycle", poi="cycle") else: cmds.setInfinity(pri="constant", poi="constant") cmds.delete(aimLoc, zeroLoc) cmds.container("BakeResultsContainer", e=True, rc=True) cmds.animLayer("BakeResults", e=True, p=layerName) cmds.rename("BakeResults", layerComp) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() else: cmds.animLayer(layerName) cmds.animLayer(layerName, e=True, p=mainLayerName) cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="rotate") cmds.select(listObjects[i], r=True) if (cycleInfinity): cmds.setInfinity(pri="cycle", poi="cycle") else: cmds.setInfinity(pri="constant", poi="constant") cmds.delete(aimLoc, zeroLoc) cmds.container("BakeResultsContainer", e=True, rc=True) cmds.animLayer("BakeResults", e=True, p=layerName) cmds.rename("BakeResults", layerComp) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() cmds.select(d=True) for l in listObjects: cmds.select(l, add=True) print "\n||| OVERLAPPY end |||\n"
def translationStart(): global asT asT = cmds.playbackOptions(query=True, min=True) # Get min anim range global aeT aeT = cmds.playbackOptions(query=True, max=True) # Get max anim range resetLoopTime() global listObjects listObjects = cmds.ls(sl=True) # Get list of selected objects #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global listFixed listFixed = listObjects[:] for i in range(len(listFixed)): listFixed[i] = listFixed[i].replace("|", "_") listFixed[i] = listFixed[i].replace(":", "_") #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| global mainLayerName mainLayerName = "OVERLAPPY" # Name of main layer if (cmds.objExists(mainLayerName)): print "\n||| OVERLAPPY start |||\n" else: cmds.animLayer(mainLayerName) print "\n||| OVERLAPPY start ||| Layer created |||\n" #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| for i in range(len(listFixed)): global aimLoc aimLoc = listFixed[i] + "_aim_loc" # Aim locator name global tempLoc tempLoc = listFixed[i] + "_temp_loc" # Physical locator name global tempPart tempPart = listFixed[i] + "_temp_part" # nParticle name global tempNucl tempNucl = "nucleus1" # Nucleus node name global partAimLoc partAimLoc = aimLoc + ".translate" # Aim locator position pull global partRtype partRtype = tempPart + "Shape.particleRenderType" # nParticle render type pull global partRrad partRrad = tempPart + "Shape.radius" # nParticle shape radius global partRsm partRsm = tempPart + "Shape.goalSmoothness" # Goal smoothness pull global partRwe partRwe = tempPart + "Shape.goalWeight[0]" # Goal weight pull global partPos partPos = tempPart + ".center" # nParticle center position pull global partNucl partNucl = tempNucl + ".timeScale" # Time scale pull global nuclStart nuclStart = tempNucl + ".startFrame" # Start frame of simulation nucleus node cmds.spaceLocator(n=tempLoc) cmds.matchTransform(tempLoc, listObjects[i], pos=True) objCenter = tempLoc + ".translate" objC = cmds.getAttr(objCenter) locCenter = tempLoc + ".center" locTr = tempLoc + ".translate" cmds.nParticle(p=objC, n=tempPart, c=1) cmds.goal(tempPart, w=goalW, utr=1, g=tempLoc) cmds.select(tempLoc, r=True) cmds.select(listObjects[i], add=True) cmds.parent(r=True) cmds.matchTransform(tempLoc, listObjects[i], pos=True) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.setAttr(partRtype, pShape) cmds.setAttr(partRrad, pRad) cmds.setAttr(partRsm, goalSmooth) cmds.setAttr(partRwe, goalW) cmds.setAttr(partNucl, timeScale) cmds.setAttr(nuclStart, asT) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| cmds.duplicate(tempLoc, rr=True, n=aimLoc) cmds.select(aimLoc, r=True) cmds.parent(w=True) cmds.connectAttr(partPos, partAimLoc, f=True) global minLoopTime minLoopTime = aeT * -3 global maxLoopTime maxLoopTime = aeT * 4 if (cycle): cmds.setAttr(nuclStart, minLoopTime) cmds.bakeResults(aimLoc, t=(minLoopTime, maxLoopTime), sm=True, at="translate") cmds.delete(tempLoc, tempPart, tempNucl) setTimeToMin() cmds.select(aimLoc, r=True) cmds.select(listObjects[i], add=True) cmds.parentConstraint(mo=True, sr=["x", "y", "z"], w=1) resetLoopTime() else: cmds.bakeResults(aimLoc, t=(asT, aeT), sm=True, at="translate") cmds.delete(tempLoc, tempPart, tempNucl) resetLoopTime() cmds.select(aimLoc, r=True) cmds.select(listObjects[i], add=True) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||| attrX = listObjects[i] + '.translateX' attrY = listObjects[i] + '.translateY' attrZ = listObjects[i] + '.translateZ' lockX = cmds.getAttr(attrX, lock=True) lockY = cmds.getAttr(attrY, lock=True) lockZ = cmds.getAttr(attrZ, lock=True) if (lockX != True): cmds.parentConstraint(mo=True, st=["y", "z"], sr=["x", "y", "z"], w=1) if (lockY != True): cmds.parentConstraint(mo=True, st=["x", "z"], sr=["x", "y", "z"], w=1) if (lockZ != True): cmds.parentConstraint(mo=True, st=["x", "y"], sr=["x", "y", "z"], w=1) #|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| layerBase = "translate_" layerName = layerBase + listFixed[i] layerComp = listFixed[i] + '_layer_{0}'.format("0") if (cmds.objExists(layerName)): cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") cmds.select(listObjects[i], r=True) if (cycleInfinity): cmds.setInfinity(pri="cycle", poi="cycle") else: cmds.setInfinity(pri="constant", poi="constant") cmds.delete(aimLoc) cmds.container("BakeResultsContainer", e=True, rc=True) cmds.animLayer("BakeResults", e=True, p=layerName) cmds.rename("BakeResults", layerComp) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() else: cmds.animLayer(layerName) cmds.animLayer(layerName, e=True, p=mainLayerName) cmds.bakeResults(listObjects[i], t=(asT, aeT), sm=True, bol=True, at="translate") cmds.select(listObjects[i], r=True) if (cycleInfinity): cmds.setInfinity(pri="cycle", poi="cycle") else: cmds.setInfinity(pri="constant", poi="constant") cmds.delete(aimLoc) cmds.container("BakeResultsContainer", e=True, rc=True) cmds.animLayer("BakeResults", e=True, p=layerName) cmds.rename("BakeResults", layerComp) #cmds.deleteAttr( n=listObjects[i], at="blendParent1" ) resetLoopTime() cmds.select(d=True) for l in listObjects: cmds.select(l, add=True) print "\n||| OVERLAPPY end |||\n"
def set_sys_parent(self, loc=''): parent_loc = loc if loc else mc.ls(sl=1)[0] mc.connectAttr('{}.sys_child'.format(parent_loc), '{}.sys_parent'.format(self.sys_data['group'])) self.update_sys_data()
def set_loc_parent(self, parent=''): parent = parent if parent else mc.ls(sl=1)[0] mc.connectAttr('{}.child'.format(parent), '{}.parent'.format(self.loc))
def test_integration_1(manager): """ 1) Create a compound 2) Register the compound 3) Modify the compound 4) Register a new version of the compound 5) Rollback to the previous version 6) Update to latest """ def _test_compound_v1(): """ Validate the namespace actually contain v1 of our test compound. :param str namespace: The compound namespace """ # Validate internal connections for src, dst in ( ("foo:inputs.input1X", "foo:multiplyDivide1"), ("foo:multiplyDivide1.outputX", "foo:outputs.outputX"), ): cmds.isConnected(src, dst) # Validate external connections for src, dst in ( ("testInn.translateX", "foo:inputs.input1X"), ("foo:outputs.outputX", "testOut.translateX"), ): cmds.isConnected(src, dst) # Validate scene content for dagpath in ( "foo:inputs", "foo:inputs.input1X", "foo:multiplyDivide1", "foo:outputs", "foo:outputs.outputX", ): assert cmds.objExists(dagpath) for dagpath in ("foo:outputs.outputY",): assert not cmds.objExists(dagpath) def _test_compound_v2(): for dagpath in ( "foo:inputs", "foo:inputs.input1X", "foo:multiplyDivide1", "foo:outputs", "foo:outputs.outputX", "foo:outputs.outputY", ): assert cmds.objExists(dagpath) # 1) Create a simple network mult1 = pymel.createNode("multiplyDivide") # Create a compound from the network compound = create_from_nodes([mult1], namespace="foo") a = mult1.input1X compound.expose_input_attr(a) compound.expose_output_attr(mult1.outputX) # Create connections from outside the compound cmds.createNode("transform", name="testInn") cmds.createNode("transform", name="testOut") cmds.connectAttr("testInn.translateX", "foo:inputs.input1X") cmds.connectAttr("foo:outputs.outputX", "testOut.translateX") _test_compound_v1() # Register the compound? compound_def_1 = CompoundDefinition( name="compound_name", version="1.0.0", uid="compound_uid" ) compound.set_metadata(dict(compound_def_1)) manager.publish_compound(compound) # Modify the scene content compound.expose_output_attr(mult1.outputY) _test_compound_v2() # TODO: Error if the file does not end with .ma? compound_def_2 = CompoundDefinition( name="compound_name", version="1.0.1", uid="compound_uid" ) compound.set_metadata(dict(compound_def_2)) manager.publish_compound(compound) cmds.connectAttr("foo:outputs.outputY", "testOut.translateY") # Downgrade our compound manager.update_compound(compound, "1.0.0") _test_compound_v1() # Upgrade our compound manager.update_compound(compound) _test_compound_v2() # Verify that we can restore our in-memory registry new_registry = Registry() new_registry.parse_directory(manager.preferences.compound_location) assert manager.registry == new_registry
def create(self): sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sRig' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInJnt) sGrpCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sCtrl' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl) sParent_jnt = sGrp lJnts = [] for i, sBpJnt in enumerate(self._lBpJnts): oJntName = naming.oName(sBpJnt) oJntName.sType = 'jnt' sJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sParent_jnt) lJnts.append(sJnt) sParent_jnt = sJnt ## rig each limb iJnts_min = len(lJnts) dRigLimbs = {} lCtrls = [] for sMode in self._dRigLimbs.keys(): dRigLimbs_each = {sMode: { 'iIndex': 0, 'class': None, 'lJnts': None, }} oLimb = self._dRigLimbs[sMode]['class'](sSide = self._sSide, iIndex = self._iIndex) oLimb._lBpJnts = self._lBpJnts oLimb._sConnectInJnt = sGrp oLimb._sConnectInCtrl = sGrpCtrl oLimb.create() if self._dRigLimbs[sMode].has_key('iIndex'): dRigLimbs_each[sMode]['iIndex'] = self._dRigLimbs[sMode]['iIndex'] else: dRigLimbs_each[sMode]['iIndex'] = namingDict.spaceDict[sMode] dRigLimbs_each[sMode]['class'] = oLimb if hasattr(oLimb, 'lJntsOutput'): dRigLimbs_each[sMode]['lJnts'] = oLimb.lJntsOutput if len(oLimb.lJntsOutput) < iJnts_min: iJnts_min = len(oLimb.lJntsOutput) else: dRigLimbs_each[sMode]['lJnts'] = oLimb.lJnts if len(oLimb.lJnts) < iJnts_min: iJnts_min = len(oLimb.lJnts) lCtrls += oLimb.lCtrls dRigLimbs.update(dRigLimbs_each) ## add shape node sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName controls.addCtrlShape(lCtrls, sCtrlShape, bVis = False) ## blend constraint joints for i in range(0, iJnts_min): lDrivers = [] #dDrivers = {'cog': {'iIndex': 0, 'sOutput': 'ctrl_m_cog'}} dDrivers = {} for sMode in dRigLimbs.keys(): dDriver_each = {sMode: {'iIndex': dRigLimbs[sMode]['iIndex'], 'sOutput': dRigLimbs[sMode]['lJnts'][i]}} dDrivers.update(dDriver_each) constraints.spaceConstraint(dDrivers, lJnts[i], sType = self._sConstraintType, sCtrl = sCtrlShape, bMaintainOffset = False, sName = self._sName, lDefaultVal = None) ## vis switch sCondition = naming.oName(sType = 'condition', sSide = self._sSide, sPart = '%s%s%sSelector' %(self._sPart, self._sName[0].upper(), self._sName[1:]), iIndex = self._iIndex).sName cmds.createNode('condition', name = sCondition) cmds.connectAttr('%s.%sModeA' %(sCtrlShape, self._sName), '%s.colorIfTrueR' %sCondition) cmds.connectAttr('%s.%sModeB' %(sCtrlShape, self._sName), '%s.colorIfFalseR' %sCondition) cmds.connectAttr('%s.%sModeBlend' %(sCtrlShape, self._sName), '%s.firstTerm' %sCondition) cmds.setAttr('%s.secondTerm' %sCondition, 0.5) cmds.setAttr('%s.operation' %sCondition, 4) lAttrs = [] lEnumIndex = [] for sMode in dRigLimbs.keys(): lAttrs.append('%s.v' %dRigLimbs[sMode]['class'].sGrpCtrl) lEnumIndex.append(dRigLimbs[sMode]['iIndex']) attributes.enumToMultiAttrs('outColorR', lAttrs, iEnumRange = len(lEnumIndex), lEnumIndex = lEnumIndex, sEnumObj = sCondition) #enumToMultiAttrs(sEnumAttr, lAttrs, iEnumRange = 2, lEnumIndex = None, lValRange = [[0,1]], sEnumObj = None) #### control connect out node sConnectOutCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sConnectOutCtrl' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sGrpCtrl, bVis = True) constraints.constraint([lJnts[-1], sConnectOutCtrl], sType = 'parent', bForce = True, bMaintainOffset = True) lCtrls = sCtrlShape ## write rig info sModuleNodes = '' sModuleIndex = '' for sMode in dRigLimbs.keys(): sModuleNodes += '%s,' %dRigLimbs[sMode]['class'].sModuleNode sModuleIndex += '%d,' %dRigLimbs[sMode]['iIndex'] sString_lJnts = self._convertListToString(lJnts) sString_lCtrls = self._convertListToString(lCtrls) lRigInfo = ['blendModeRig', sGrp, self._sConnectInJnt, self._sConnectInCtrl, lJnts[-1], sConnectOutCtrl, sString_lJnts, sString_lCtrls, sGrpCtrl, sModuleNodes[:-1], sModuleIndex[:-1]] lAttrs = ['sModuleType', 'sModuleNode', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'lModuleNodes', 'lModuleIndex'] self._writeRigInfo(sGrp, lRigInfo, lAttrs) self._getRigInfo(sGrp)
cs = x+".color" # texture attr os = x+".outColor" # sha45ding group connecte location bs = cmds.getAttr(x+".color") # Cs value bl = cmds.connectionInfo(cs, id=True) # color attr texture connection check outl = cmds.connectionInfo(os, isSource=True) outc = cmds.connectionInfo(os, dfs=True) if outl: vs = cmds.shadingNode("PxrDisney", asShader=True, n = x) #lt = cmds.shadingNode("layeredTexture", asTexture=True, n = x+"_layeredTexture") x = outc[0].split(".") x = x[0] cmds.disconnectAttr(os, outc[0]) cmds.connectAttr(vs+".outColor", outc[0]) if bl : c_name = cmds.connectionInfo(cs, sfd=True) cmds.connectAttr(c_name, vs+".baseColor") else : bs = bs[0] cmds.setAttr( vs + ".baseColor", bs[0], bs[1], bs[2])
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # declaring lists to send information for integration: self.scalableGrpList, self.ikCtrlZeroList = [], [] # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_'] for s, side in enumerate(sideList): duplicated = cmds.duplicate(self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename(self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: for axis in self.mirrorAxis: cmds.setAttr(side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.skinJointList = [] self.base = side + self.userGuideName + '_Guide_Base' # get the number of joints to be created: self.nJoints = cmds.getAttr(self.base + ".nJoints") for n in range(0, self.nJoints + 1): cmds.select(clear=True) # declare guide: self.guide = side + self.userGuideName + "_Guide_JointLoc" + str(n) # create a joint: self.jnt = cmds.joint(name=side + self.userGuideName + "_" + str(n) + "_Jnt", scaleCompensate=False) self.skinJointList.append(self.jnt) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) # create a control: if n == 1: self.ctrl = ctrls.cvFinger(ctrlName=side + self.userGuideName + "_" + str(n) + "_Ctrl", r=self.ctrlRadius) cmds.setAttr(self.ctrl + ".rotateOrder", 1) utils.originedFrom(objName=self.ctrl, attrString=self.base + ";" + self.guide) # edit the mirror shape to a good direction of controls: if s == 1: if self.mirrorAxis == 'X': cmds.setAttr(self.ctrl + '.rotateZ', 180) elif self.mirrorAxis == 'Y': cmds.setAttr(self.ctrl + '.rotateY', 180) elif self.mirrorAxis == 'Z': cmds.setAttr(self.ctrl + '.rotateZ', 180) elif self.mirrorAxis == 'XY': cmds.setAttr(self.ctrl + '.rotateX', 180) elif self.mirrorAxis == 'XYZ': cmds.setAttr(self.ctrl + '.rotateZ', 180) cmds.makeIdentity(self.ctrl, apply=True, translate=False, rotate=True, scale=False) else: self.ctrl = cmds.circle(name=side + self.userGuideName + "_" + str(n) + "_Ctrl", degree=1, normal=(0, 0, 1), r=self.ctrlRadius, s=6, ch=False)[0] cmds.setAttr(self.ctrl + ".rotateOrder", 1) utils.originedFrom(objName=self.ctrl, attrString=self.guide) if n == 0: if self.nJoints == 2: # problably we are creating the first control to a thumb cmds.scale(2, 2, 2, self.ctrl, relative=True) cmds.makeIdentity(self.ctrl, apply=True) else: # problably we are creating other base controls cmds.scale(2, 0.5, 1, self.ctrl, relative=True) cmds.makeIdentity(self.ctrl, apply=True) # scaleCompensate attribute: #Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone if (int(cmds.about(version=True)[:4]) < 2016): if n > 0 or self.nJoints == 2: cmds.addAttr(self.ctrl, longName="scaleCompensate", attributeType='bool', keyable=True) scaleCompensateCond = cmds.createNode("condition", name=side + self.userGuideName + "_" + str(n) + "_ScaleCompensate_Cnd") cmds.setAttr(scaleCompensateCond + ".secondTerm", 1) cmds.connectAttr(self.ctrl + ".scaleCompensate", scaleCompensateCond + ".colorIfTrueR", force=True) cmds.connectAttr(scaleCompensateCond + ".outColorR", self.jnt + ".segmentScaleCompensate", force=True) # hide visibility attribute: cmds.setAttr(self.ctrl + '.visibility', keyable=False) # put another group over the control in order to use this to connect values from mainFingerCtrl: self.sdkGrp = cmds.group(self.ctrl, name=side + self.userGuideName + "_" + str(n) + "_SDKGrp") if n == 1: # change pivot of this group to control pivot: pivotPos = cmds.xform(self.ctrl, query=True, worldSpace=True, rotatePivot=True) cmds.setAttr(self.sdkGrp + '.rotatePivotX', pivotPos[0]) cmds.setAttr(self.sdkGrp + '.rotatePivotY', pivotPos[1]) cmds.setAttr(self.sdkGrp + '.rotatePivotZ', pivotPos[2]) # position and orientation of joint and control: tempDel = cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False) cmds.delete(tempDel) tempDel = cmds.parentConstraint(self.guide, self.sdkGrp, maintainOffset=False) cmds.delete(tempDel) # zeroOut controls: utils.zeroOut([self.sdkGrp]) # create end joint: self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" self.endJoint = cmds.joint(name=side + self.userGuideName + "_JEnd", scaleCompensate=False) tempDel = cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False) cmds.delete(tempDel) cmds.parent(self.endJoint, side + self.userGuideName + "_" + str(self.nJoints) + "_Jnt", absolute=True) # grouping: for n in range(0, self.nJoints + 1): self.jnt = side + self.userGuideName + "_" + str(n) + "_Jnt" self.ctrl = side + self.userGuideName + "_" + str(n) + "_Ctrl" self.zeroCtrl = side + self.userGuideName + "_" + str(n) + "_SDKGrp_Zero" if n > 0: if n == 1: if not cmds.objExists(self.ctrl + '.ikFkBlend'): cmds.addAttr(self.ctrl, longName="ikFkBlend", attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0) self.ikFkRevNode = cmds.createNode("reverse", name=side + self.userGuideName + "_ikFk_Rev") cmds.connectAttr(self.ctrl + ".ikFkBlend", self.ikFkRevNode + ".inputX", force=True) if not cmds.objExists(self.ctrl + '.' + self.langDic[self.langName]['c_showControls']): cmds.addAttr(self.ctrl, longName=self.langDic[self.langName]['c_showControls'], attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0) self.ctrlShape0 = cmds.listRelatives(side + self.userGuideName + "_0_Ctrl", children=True, type='nurbsCurve')[0] cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_showControls'], self.ctrlShape0 + ".visibility", force=True) cmds.setAttr(self.ctrl + '.' + self.langDic[self.langName]['c_showControls'], keyable=False, channelBox=True) for j in range(1, self.nJoints + 1): cmds.addAttr(self.ctrl, longName=self.langDic[self.langName]['c_falange'] + str(j), attributeType='float', keyable=True) # parent joints as a simple chain (line) self.fatherJnt = side + self.userGuideName + "_" + str(n - 1) + "_Jnt" cmds.parent(self.jnt, self.fatherJnt, absolute=True) # parent zeroCtrl Group to the before ctrl: self.fatherCtrl = side + self.userGuideName + "_" + str(n - 1) + "_Ctrl" cmds.parent(self.zeroCtrl, self.fatherCtrl, absolute=True) # freeze joints rotation cmds.makeIdentity(self.jnt, apply=True) # create parent and scale constraints from ctrl to jnt: cmds.delete(cmds.parentConstraint(self.ctrl, self.jnt, maintainOffset=False, name=self.jnt + "_ParentConstraint")) # make first falange be leads from base finger control: cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_1_SDKGrp_Zero", maintainOffset=True, name=side + self.userGuideName + "_1_SDKGrp_Zero" + "_ParentConstraint") cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_1_SDKGrp_Zero", maintainOffset=True, name=side + self.userGuideName + "_1_SDKGrp_Zero" + "_ScaleConstraint") if self.nJoints != 2: cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Jnt", maintainOffset=True, name=side + self.userGuideName + "_ParentConstraint") cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Jnt", maintainOffset=True, name=side + self.userGuideName + "_ScaleConstraint") # connecting the attributes from control 1 to falanges rotate: for n in range(1, self.nJoints + 1): self.ctrl = side + self.userGuideName + "_1_Ctrl" self.sdkGrp = side + self.userGuideName + "_" + str(n) + "_SDKGrp" cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_falange'] + str(n), self.sdkGrp + ".rotateY", force=True) if n > 1: self.ctrlShape = cmds.listRelatives(side + self.userGuideName + "_" + str(n) + "_Ctrl", children=True, type='nurbsCurve')[0] cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_showControls'], self.ctrlShape + ".visibility", force=True) # ik and Fk setup if self.nJoints == 2: dupIk = cmds.duplicate(self.skinJointList[0])[0] dupFk = cmds.duplicate(self.skinJointList[0])[0] else: dupIk = cmds.duplicate(self.skinJointList[1])[0] dupFk = cmds.duplicate(self.skinJointList[1])[0] # hide ik and fk joints in order to be rigger friendly whe skinning cmds.setAttr(dupIk+".visibility", 0) cmds.setAttr(dupFk+".visibility", 0) # ik setup childrenIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True) if childrenIkList: for child in childrenIkList: if not cmds.objectType(child) == "joint": cmds.delete(child) jointIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True) for jointNode in jointIkList: if "_Jnt" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_Jnt", "_Ik_Jxt")) elif "_JEnd" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_JEnd", "_Ik_JEnd")) ikBaseJoint = cmds.rename(dupIk, dupIk.replace("_Jnt1", "_Ik_Jxt")) ikJointList = cmds.listRelatives(ikBaseJoint, children=True, allDescendents=True) ikJointList.append(ikBaseJoint) # Fk setup childrenFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True) if childrenFkList: for child in childrenFkList: if not cmds.objectType(child) == "joint": cmds.delete(child) jointFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True) for jointNode in jointFkList: if "_Jnt" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_Jnt", "_Fk_Jxt")) elif "_JEnd" in jointNode[jointNode.rfind("|"):]: cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_JEnd", "_Fk_JEnd")) fkBaseJoint = cmds.rename(dupFk, dupFk.replace("_Jnt2", "_Fk_Jxt")) fkJointList = cmds.listRelatives(fkBaseJoint, children=True, allDescendents=True) fkJointList.append(fkBaseJoint) # ik fk blend connnections for i, ikJoint in enumerate(ikJointList): if not "_JEnd" in ikJoint: if cmds.objExists(ikJoint + ".dpAR_joint"): cmds.deleteAttr(ikJoint + ".dpAR_joint") fkJoint = ikJoint.replace("_Ik_Jxt", "_Fk_Jxt") skinJoint = ikJoint.replace("_Ik_Jxt", "_Jnt") self.ctrl = side + self.userGuideName + "_1_Ctrl" scaleCompensateCond = ikJoint.replace("_Ik_Jxt", "_ScaleCompensate_Cnd") ikFkParentConst = cmds.parentConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint + "_ParentConstraint")[0] ikFkScaleConst = cmds.scaleConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint + "_ScaleConstraint")[0] cmds.connectAttr(self.ctrl + ".ikFkBlend", ikFkParentConst + "." + fkJoint + "W1", force=True) cmds.connectAttr(self.ikFkRevNode + ".outputX", ikFkParentConst + "." + ikJoint + "W0", force=True) cmds.connectAttr(self.ctrl + ".ikFkBlend", ikFkScaleConst + "." + fkJoint + "W1", force=True) cmds.connectAttr(self.ikFkRevNode + ".outputX", ikFkScaleConst + "." + ikJoint + "W0", force=True) cmds.setAttr(ikJoint + ".segmentScaleCompensate", 1) #Condition for scale compensate will not exist in maya 2016 since we need to have the compensate #off for almost every joint if (int(cmds.about(version=True)[:4]) < 2016): cmds.connectAttr(self.ctrl + ".ikFkBlend", scaleCompensateCond + ".firstTerm", force=True) # fk control drives fk joints for i, fkJoint in enumerate(fkJointList): if not "_JEnd" in fkJoint: if cmds.objExists(fkJoint + ".dpAR_joint"): cmds.deleteAttr(fkJoint + ".dpAR_joint") fkCtrl = fkJoint.replace("_Fk_Jxt", "_Ctrl") scaleCompensateCond = fkCtrl.replace("_Ctrl", "_ScaleCompensate_Cnd") cmds.parentConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint + "_ParentConstraint") cmds.scaleConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint + "_ScaleConstraint") #Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone if (int(cmds.about(version=True)[:4]) < 2016): cmds.connectAttr(fkCtrl + ".scaleCompensate", fkJoint + ".segmentScaleCompensate", force=True) else: cmds.setAttr(fkJoint + ".segmentScaleCompensate", 0) cmds.setAttr(fkCtrl + ".rotateOrder", 1) #Force Scale compensate to prevent scale problem in Maya 2016 for nJnt in self.skinJointList: if (int(cmds.about(version=True)[:4]) >= 2016): cmds.setAttr(nJnt + ".segmentScaleCompensate", 0) # ik handle if self.nJoints >= 2: if self.nJoints == 2: ikHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_0_Ik_Jxt", endEffector=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", solver="ikRPsolver", name=side + self.userGuideName + "_IkHandle") else: ikHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_1_Ik_Jxt", endEffector=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", solver="ikRPsolver", name=side + self.userGuideName + "_IkHandle") cmds.rename(ikHandleList[1], side + self.userGuideName + "_Effector") endIkHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", endEffector=side + self.userGuideName + "_Ik_JEnd", solver="ikSCsolver", name=side + self.userGuideName + "_EndIkHandle") cmds.rename(endIkHandleList[1], side + self.userGuideName + "_EndEffector") self.ikCtrl = ctrls.cvBox(ctrlName=side + self.userGuideName + "_Ik_Ctrl", r=self.ctrlRadius*0.3) cmds.addAttr(self.ikCtrl, longName='twist', attributeType='float', keyable=True) cmds.connectAttr(self.ikCtrl + ".twist", ikHandleList[0] + ".twist", force=True) cmds.delete(cmds.parentConstraint(side + self.userGuideName + "_Ik_JEnd", self.ikCtrl)) cmds.setAttr(self.ikCtrl + ".rotateOrder", 1) self.ikCtrlZero = utils.zeroOut([self.ikCtrl])[0] self.ikCtrlZeroList.append(self.ikCtrlZero) cmds.connectAttr(self.ikFkRevNode + ".outputX", self.ikCtrlZero + ".visibility", force=True) for q in range(2, self.nJoints): cmds.connectAttr(side + self.userGuideName + "_1_Ctrl.ikFkBlend", side + self.userGuideName + "_" + str(q) + "_Ctrl.visibility", force=True) cmds.parentConstraint(self.ikCtrl, ikHandleList[0], name=side + self.userGuideName + "_IkHandle_ParentConstraint", maintainOffset=True) cmds.parentConstraint(self.ikCtrl, endIkHandleList[0], name=side + self.userGuideName + "_EndIkHandle_ParentConstraint", maintainOffset=True) ikHandleGrp = cmds.group(ikHandleList[0], endIkHandleList[0], name=side + self.userGuideName + "_IkHandle_Grp") cmds.setAttr(ikHandleGrp+".visibility", 0) ctrls.setLockHide([self.ikCtrl], ['sx', 'sy', 'sz', 'v']) if self.nJoints == 2: cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Ik_Jxt", maintainOffset=True, name=side + self.userGuideName + "_0_Ik_Jxt_ParentConstraint") cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Ik_Jxt", maintainOffset=True, name=side + self.userGuideName + "_0_Ik_Jxt_ScaleConstraint") # stretch cmds.addAttr(self.ikCtrl, longName='stretchable', attributeType='float', minValue=0, maxValue=1, defaultValue=0, keyable=True) stretchNormMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_StretchNormalize_MD") cmds.setAttr(stretchNormMD + ".operation", 2) distBetweenList = ctrls.distanceBet(side + self.userGuideName + "_0_Ctrl", self.ikCtrl, name=side + self.userGuideName + "_DistBet", keep=True) cmds.connectAttr(self.ikFkRevNode + ".outputX", distBetweenList[5] + "." + self.ikCtrl + "W0", force=True) cmds.connectAttr(self.ctrl + ".ikFkBlend", distBetweenList[5] + "." + distBetweenList[4] + "W1", force=True) cmds.connectAttr(distBetweenList[1] + ".distance", stretchNormMD + ".input1X", force=True) cmds.setAttr(stretchNormMD + ".input2X", distBetweenList[0]) stretchScaleMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_StretchScale_MD") cmds.connectAttr(stretchNormMD + ".outputX", stretchScaleMD + ".input1X", force=True) cmds.connectAttr(self.ikCtrl + ".stretchable", stretchScaleMD + ".input2X", force=True) stretchCond = cmds.createNode("condition", name=side + self.userGuideName + "_Stretch_Cnd") cmds.connectAttr(stretchScaleMD + ".outputX", stretchCond + ".firstTerm", force=True) cmds.setAttr(stretchCond + ".secondTerm", 1) cmds.setAttr(stretchCond + ".operation", 2) cmds.connectAttr(stretchScaleMD + ".outputX", stretchCond + ".colorIfTrueR", force=True) for i, ikJoint in enumerate(ikJointList): if not "_JEnd" in ikJoint: if self.nJoints == 2 and i == 0: pass else: cmds.connectAttr(stretchCond + ".outColorR", ikJoint + ".scaleZ", force=True) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group(self.ikCtrlZero, side + self.userGuideName + "_0_SDKGrp_Zero", side + self.userGuideName + "_1_SDKGrp_Zero", name=side + self.userGuideName + "_Control_Grp") if self.nJoints == 2: self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", ikBaseJoint, fkBaseJoint, ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side + self.userGuideName + "_Joint_Grp") else: self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side + self.userGuideName + "_Joint_Grp") else: self.toCtrlHookGrp = cmds.group(side + self.userGuideName + "_0_SDKGrp_Zero", side + self.userGuideName + "_1_SDKGrp_Zero", name=side + self.userGuideName + "_Control_Grp") self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", name=side + self.userGuideName + "_Joint_Grp") self.scalableGrpList.append(self.toScalableHookGrp) self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def main(name="assembly", position=(0,0,0), radius=1, fbx=False, cog=True, body=True, pelvis=True): if type(position) == str or type(position) == unicode: position = mc.xform(position, q=True, rp=True, ws=True) grp = mc.createNode("transform", n=name) mc.addAttr(grp, ln="joints", at="bool", dv=True, k=True) mc.addAttr(grp, ln="editJoints", at="bool", k=True) if fbx: mc.setAttr(grp+".joints", False) mc.addAttr(grp, ln="fbxJoints", at="bool", dv=True, k=True) mc.addAttr(grp, ln="editFbxJoints", at="bool", k=True) mc.addAttr(grp, ln="controls", at="bool", dv=True, k=True) mc.addAttr(grp, ln="_geometry", at="bool", dv=True, k=True) mc.addAttr(grp, ln="editGeometry", at="bool", k=True) # # controls # ctrl = [] ctrl.append(common.control(name="world", parent=grp, radius=radius*5, color=13, lockAttr=["v"], hideAttr=["v"])[1]) if cog: ctrl.append(common.control(name="cog", parent=ctrl[0], position=position, color=13, radius=radius*4, lockAttr=["s","v"], hideAttr=["sx","sy","sz","v"])[1]) if body: ctrl.append(common.control(name="body", parent=ctrl[1], position=ctrl[1], color=13, radius=radius*3, lockAttr=["s","v"], hideAttr=["sx","sy","sz","v"])[1]) if pelvis: ctrl.append(common.control(name="pelvis", parent=ctrl[2], position=ctrl[2], radius=radius*2, lockAttr=["s","v"], hideAttr=["sx","sy","sz","v"])[1]) grps = [None]*2 rev = mc.createNode("reverse") if fbx: grps[0] = mc.createNode("transform", n="skeleton_fbx") grps[1] = mc.createNode("transform", n="geometry_fbx") mc.connectAttr(grp+".fbxJoints", grps[0]+".v") mc.setAttr(grps[0]+".overrideDisplayType", 2) mc.connectAttr(grp+".editFbxJoints", rev+".inputX") mc.connectAttr(rev+".outputX", grps[0]+".overrideEnabled") mc.createNode("transform", n="constraints_fbx", p=grp) else: grps[1] = mc.createNode("transform", n="geometry", p=grp) mc.connectAttr(grp+"._geometry", grps[1]+".v") mc.connectAttr(grp+".editGeometry", rev+".inputY") mc.connectAttr(rev+".outputY", grps[1]+".overrideEnabled") mc.setAttr(grps[1]+".overrideDisplayType", 2) for n in grps: for a in ["tx","ty","tz","rx","ry","rz","sx","sy","sz","v"]: try: mc.setAttr(n+"."+a, l=True, k=False, cb=False) except: pass # # selection sets # n1 = mc.sets(n="ik_controls_set", em=True) n2 = mc.sets(n="fk_controls_set", em=True) for n in ctrl: mc.connectAttr(n+".message", n2+".dnSetMembers", na=True) n3 = mc.sets(n="joints_set", em=True) n4 = mc.sets(n=name+"_set", em=True) mc.sets(n1, n2, n3, add=n4) mc.select(grp) mc.dgdirty(a=True) return grp
def rebuild(self): """ Rebuild the wire deformer from the recorded deformerData """ # ========== # - Checks - # ========== # Check Data for influence in self._influenceData.iterkeys(): # Check Wire Curve if not cmds.objExists(influence): print('Wire curve "' + influence + '" does not exist! Curve will not be added to deformer!') # Check Base Curves baseCurve = self._influenceData[influence]['influenceBase'] if not cmds.objExists(baseCurve): print( 'Wire curve base "' + baseCurve + '" does not exist! A static base curve will be generated from the deforming wire curve!' ) # Check Dropoff Locators for locator in self._locatorData.iterkeys(): if cmds.objExists(locator): cmds.delete(cmds.listRelatives(locator, p=True)[0]) # ==================== # - Rebuild Deformer - # ==================== result = super(WireData, self).rebuild() wireDeformer = result['deformer'] # ======================= # - Connect Wire Curves - # ======================= for influence in self._influenceData.iterkeys(): # Get current wire curve pair wireCurve = influence infIndex = self._influenceData[influence]['index'] baseCurve = self._influenceData[influence]['influenceBase'] # Connect deformed wire if not cmds.objExists(influence): continue cmds.connectAttr(wireCurve + '.worldSpace[0]', wireDeformer + '.deformedWire[' + str(infIndex) + ']', f=True) # Connect base wire if not cmds.objExists(baseCurve): baseCurve = cmds.duplicate(influence, n=baseCurve)[0] cmds.connectAttr(baseCurve + '.worldSpace[0]', wireDeformer + '.baseWire[' + str(infIndex) + ']', f=True) cmds.setAttr(baseCurve + '.v', 0) # Set Influence Attributes if cmds.getAttr(wireDeformer + '.dropoffDistance[' + str(infIndex) + ']', se=True): cmds.setAttr( wireDeformer + '.dropoffDistance[' + str(infIndex) + ']', self._influenceData[influence]['dropoffDist']) if cmds.getAttr(wireDeformer + '.scale[' + str(infIndex) + ']', se=True): cmds.setAttr(wireDeformer + '.scale[' + str(infIndex) + ']', self._influenceData[influence]['scale']) # ============================ # - Rebuild Dropoff Locators - # ============================ for locator in self._locatorData.iterkeys(): # Get data parent = self._locatorData[locator]['parent'] param = self._locatorData[locator]['parameter'] env = self._locatorData[locator]['envelope'] percent = self._locatorData[locator]['percent'] twist = self._locatorData[locator]['twist'] # Create Locator loc = cmds.dropoffLocator(env, percent, wire, parent + '.u[' + str(param) + ']')[0] # Apply Twist locConn = cmds.listConnections(loc + '.param', s=False, d=True, p=True)[0] locConnIndex = locConn.split('[')[-1].split(']')[0] cmds.setAttr( wireDeformer + '.wireLocatorTwist[' + str(locConnIndex) + ']', twist) # ================= # - Return Result - # ================= self.result['influence'] = self._influenceData.keys() self.result['dropoffLocator'] = self._locatorData.keys() return self.result
def _establish_connections(self): reverseRzNode = cmd.shadingNode('multDoubleLinear', n='reverse_Rx', asUtility=True) normalizeNode = cmd.shadingNode('vectorProduct', n='normalize', asUtility=True) cmd.setAttr(normalizeNode + '.operation', 0) cmd.setAttr(normalizeNode + '.normalizeOutput', 1) cmd.setAttr(normalizeNode + '.input1Y', 0.001) cmd.connectAttr(self.ctrl + '.rx', normalizeNode + '.input1X') cmd.setAttr(reverseRzNode + '.input2', -1) cmd.connectAttr(self.ctrl + '.rz', reverseRzNode + '.input1') cmd.connectAttr(reverseRzNode + '.output', normalizeNode + '.input1Z') cmd.connectAttr(normalizeNode + '.outputX', self.locator + '.tz') cmd.connectAttr(normalizeNode + '.outputZ', self.locator + '.tx') cmd.connectAttr(self.locator + '.tz', self.ctrl_loc + '.rotatePivotZ') cmd.connectAttr(self.locator + '.tx', self.ctrl_loc + '.rotatePivotX') # cmd.setAttr(self.ctrl_loc+'.rotatePivotY', 0) cmd.connectAttr(self.ctrl + '.rotate', self.ctrl_loc + '.rotate') self._reconstructCurve()
drvnAttr = 'visibility' drvnVal = 1 cmds.setDrivenKeyframe('%s.%s' %(drvnObj, drvnAttr), cd = '%s.%s' %(drvrObj, drvrAttr), dv = drvrVal, v = drvnVal) # Smooth Level Set Up # ctrlToAddAttr = 'Main' # Connect smoothLevel attribute to render geometry's smoothLevel attribute. cmds.select(cmds.ls(sl = True), hi = True, r = True) shpLs = cmds.ls(sl = True, type = 'mesh') for shp in shpLs: try: cmds.connectAttr('%s.smoothLevel' %(ctrlToAddAttr), '%s.smoothLevel' %(shp), f = True) except: pass # Trun Off Shape Visibility # sels = cmds.ls(sl = True) for sel in sels: selShp = cmds.listRelatives(sel, s = True)[0] cmds.setAttr('%s.visibility' %selShp, 0)
# mc.loadPlugin(os.path.join(MAYA_APP_DIR, 'scripts\dsRaycast\dsDrawVector\plugins\dsDrawVector.py')) mc.loadPlugin( os.path.join(MAYA_APP_DIR, 'scripts/dsRaycast/plugins/dsRaycast.py')) ###### Test ######### # Basic test mesh = mc.polyPlane()[0] mc.move(0, 4, 0, mesh) mc.scale(50, 50, 50, mesh) source = mc.spaceLocator(n='source')[0] mc.move(0, 10, 0, source) aim = mc.spaceLocator(n='aim')[0] dsRaycast = mc.createNode('dsRaycast') mc.connectAttr(mesh + '.worldMesh', dsRaycast + '.tm') mc.connectAttr(source + '.worldMatrix', dsRaycast + '.srs') mc.connectAttr(aim + '.t', dsRaycast + '.aim') testObj = mc.polyCube(n='testBoi00') mc.connectAttr(dsRaycast + ".hitPoint", testObj[0] + ".t") ''' #Wheel test mesh = mc.polyPlane() srsLocs =[] wheelGeo =[] meshShape = mc.listRelatives(mesh, type='shape')[0] mc.move(0, 2, 0, mesh[0]) mc.setAttr(mesh[1] + '.width', 50) mc.setAttr(mesh[1] + '.height', 50)
def etc_set( self ): ### attribute # sup con vis for x in range(8): cmds.addAttr ( TP.AA['PL'][x], ln='sub_con_vis', at='enum', en='off:on:' ) cmds.setAttr ( TP.AA['PL'][x]+'.sub_con_vis', e=1, keyable=1 ) cmds.connectAttr ( TP.AA['PL'][x]+'.sub_con_vis', TP.AA['CL'][x]+'.visibility' ) # FK / IK switch for x in range(2): switchCon = controllerShape( TP.conVis['key'][x][0]+'_CON', 'cross', 'yellow' ) switchNul = cmds.group ( switchCon, n=TP.conVis['key'][x][0]+'_NUL' ) cmds.delete ( cmds.pointConstraint ( TP.conVis['key'][x][1], switchNul ) ) cmds.parent( switchNul, TP.conVis['key'][x][1] ) cmds.move( 5, 0, 0, ws=1, r=1 ) cmds.addAttr ( switchCon, ln=TP.conVis['attr'][0], at='enum', en='off:on:' ) cmds.setAttr ( switchCon+'.'+TP.conVis['attr'][0], e=1, keyable=1 ) cmds.addAttr ( switchCon, ln=TP.conVis['attr'][1], at='enum', en='off:on:' ) cmds.setAttr ( switchCon+'.'+TP.conVis['attr'][1], e=1, keyable=1 ) for x in range(2): top_list = TP.conVis['vis'][x] for y in top_list: for z in y: if len(y)==1: cmds.connectAttr( TP.conVis['key'][x][0]+'_CON.'+TP.conVis['attr'][0], z+'.visibility' ) else: cmds.connectAttr( TP.conVis['key'][x][0]+'_CON.'+TP.conVis['attr'][1], z+'.visibility' ) cmds.setAttr ( TP.conVis['key'][x][0]+'_CON.IK_con_vis', 1 ) ### Parent node cmds.group ( p='noneTransform_GRP', em=1, n='locator_GRP' ) cmds.parent ( TP.noneTrans_list, 'locator_GRP' ) cmds.parent ( TP.attach_list, 'attach_GRP' ) cmds.parent ( TP.auxillary_list, 'auxillary_GRP' ) cmds.parent ( TP.neck_list, 'C_neck_GRP' ) cmds.parent ( TP.spine_list, 'C_spine_GRP' ) cmds.parent ( TP.L_foreLeg_list, 'L_foreLeg_GRP' ) cmds.parent ( TP.R_foreLeg_list, 'R_foreLeg_GRP' ) cmds.parent ( TP.L_hindLeg_list, 'L_hindLeg_GRP' ) cmds.parent ( TP.R_hindLeg_list, 'R_hindLeg_GRP' ) cmds.delete ( TP.delete_list ) cmds.select ( TP.noneTrans_list, r=1) cmds.select ( 'templateJoint_GRP' , tgl=1) cmds.select ( TP.hide_list , tgl=1) cmds.HideSelectedObjects () if self.ui.advTailNum_CMB.currentText() == 'Normal': cmds.parent ( TP.tail_list, 'C_tail_GRP' ) cmds.select ( TP.hide_list2 , r=1 ) cmds.select ( 'tail_aim_vector_LOC',tgl=1 ) cmds.HideSelectedObjects () else: cmds.parent ( 'Skin_tail1_JNT', 'SkinJoint_GRP' ) cmds.parent ( 'tail1_NUL', 'FKControl_GRP') cmds.parent ( 'tail_curve_locator_GRP', 'attach_GRP') cmds.select ( TP.hide_list2[0:-2] , r=1) cmds.HideSelectedObjects () ### Rotate controler self.controlerRotate( TP.rotate_con_list_A, 0, 0, -90 ) self.controlerRotate( TP.rotate_con_list_B, -90, 0, 0 ) ### controler Color for x in TP.R_con_list: conShapeName = cmds.listRelatives ( x, s=1 )[0] cmds.setAttr ( conShapeName+'.overrideEnabled', 1 ) cmds.setAttr ( conShapeName+'.overrideColor', 13 ) for x in TP.switch_con_list: conShapeName = cmds.listRelatives ( x, s=1 )[0] cmds.setAttr ( conShapeName+'.overrideEnabled', 1 ) cmds.setAttr ( conShapeName+'.overrideColor', 14 ) ### controler Scale for x in TP.scale_con_list: scale_value = 2 CRV_shape_name = cmds.listRelatives (x, s=1)[0] CRV_span_num = cmds. getAttr ( CRV_shape_name+'.spans' ) cmds.select ( x+'.cv[0:%s]' %(CRV_span_num)) cmds.scale ( scale_value, scale_value, scale_value, r=1 ) ### controler Parent if self.ui.advTailNum_CMB.currentText() == 'Normal': for x in range(2): PL = TP.parent_list['PL'][x] for y in TP.parent_list['CL'][x]: print y cmds.parentConstraint ( PL, y, mo=1 ) else: del TP.parent_list['CL'][0][3] for x in range(2): PL = TP.parent_list['PL'][x] for y in TP.parent_list['CL'][x]: print y cmds.parentConstraint ( PL, y, mo=1 ) ### hindLeg Parent cmds.setAttr ( 'L_rig_hip_JNT.inheritsTransform', 0 ) cmds.setAttr ( 'R_rig_hip_JNT.inheritsTransform', 0 ) itemList = [ '.sx', '.sy', '.sz' ] for x in TP.targetjointList: for y in itemList: cmds.connectAttr ( 'place_CON.globalScale', x+y )
def dupToCurveFlow(): allSel = mc.ls(sl=True) count = len(allSel) if count < 2: om.MGlobal.displayError( 'Please select some will follow Curve Objects and Curve...') return curveSel = mc.ls(sl=True, tail=1) if mc.nodeType(curveSel[0]) == 'transform': curveShape = mc.listRelatives(curveSel, shapes=True) if mc.nodeType(curveShape[0]) == 'nurbsCurve': shape = curveShape[0] elif mc.nodeType(curveSel[0]) == 'nurbsCurve': shape = curveSel[0] else: om.MGlobal.displayError('Please select lastest Curve...') return _min = mc.getAttr(shape + '.minValue') _max = mc.getAttr(shape + '.maxValue') objSel = allSel[:count - 1] for eachObj in objSel: if mc.attributeQuery('translate', node=eachObj, ex=True) == False: om.MGlobal.displayWarning( '%s Object have not "Transform" attribute,ingore it...' % eachObj) objSel.remove(eachObj) elif mc.attributeQuery('rotate', node=eachObj, ex=True) == False: om.MGlobal.displayWarning( '%s Object have not "Rotate" attribute,ingore it...' % eachObj) objSel.remove(eachObj) _length = _max - _min segment = _length / (len(objSel) - 1) if not mc.pluginInfo('dupToCurveFlowPlugin.py', q=True, l=True): mc.loadPlugin( r'\\octvision.com\cg\TD\Maya\2012\Plugins\dupToCurveFlowPlugin.py') icNode = mc.createNode('ic_dupToCurveFlow') mc.connectAttr(shape + '.local', icNode + '.inCurve', f=True) for i in range(0, len(objSel)): mc.getAttr(icNode + '.outTranslate[%i]' % i) mc.getAttr(icNode + '.outRotate[%i]' % i) if not mc.attributeQuery('param', node=objSel[i], ex=True): mc.addAttr(objSel[i], ln='param', at='double') mc.setAttr(objSel[i] + '.param', e=True, keyable=True) mc.connectAttr(objSel[i] + '.param', icNode + '.inParam[%i]' % i, f=True) mc.connectAttr(icNode + '.outTranslate[%i].outTranslateX' % i, objSel[i] + '.translateX', f=True) mc.connectAttr(icNode + '.outTranslate[%i].outTranslateY' % i, objSel[i] + '.translateY', f=True) mc.connectAttr(icNode + '.outTranslate[%i].outTranslateZ' % i, objSel[i] + '.translateZ', f=True) mc.connectAttr(icNode + '.outRotate[%i].outRotateX' % i, objSel[i] + '.rotateX', f=True) mc.connectAttr(icNode + '.outRotate[%i].outRotateY' % i, objSel[i] + '.rotateY', f=True) mc.connectAttr(icNode + '.outRotate[%i].outRotateZ' % i, objSel[i] + '.rotateZ', f=True) mc.setAttr(objSel[i] + '.param', segment * i)
def rigSpline(): selection = cmds.ls(selection=True) cmds.duplicate(selection) cmds.rename('spine4') RIGJointStart1 = cmds.ls(selection=True) mel.eval("pickWalk -d down;") cmds.rename('spine3') RIGJoint2 = cmds.ls(selection=True) mel.eval("pickWalk -d down;") cmds.rename('spine2') RIGJoint3 = cmds.ls(selection=True) mel.eval("pickWalk -d down;") cmds.rename('spine1') RIGJointFinal4 = cmds.ls(selection=True) mel.eval("pickWalk -d down;") BaseControl = cmds.circle(n='spine_base_Control') FinalControl = cmds.circle(n='spine_final_Control') BaseControlNull = cmds.group(em=True, n='spine_base_Null') FinalControlNull = cmds.group(em=True, n='spine_final_Null') cmds.parent(BaseControl, BaseControlNull) cmds.parent(FinalControl, FinalControlNull) cmds.delete(cmds.parentConstraint(RIGJointStart1, BaseControlNull)) cmds.delete(cmds.parentConstraint(RIGJointFinal4, FinalControlNull)) cmds.rotate(0, '90deg', 0, 'spine_base_Null') cmds.rotate(0, '90deg', 0, 'spine_final_Null') cmds.makeIdentity(apply=True, rotate=True, translate=True, scale=True) # Spline Ik and curve splineHandle = cmds.ikHandle(name='spline_ik_handle', solver='ikSplineSolver', startJoint=RIGJointStart1[0], ee=RIGJointFinal4[0], p=1, w=1, createCurve=True, parentCurve=True) cmds.parent("spline_ik_handle", BaseControl) cmds.select(BaseControl) cmds.addAttr(sn="rl", longName="Roll", attributeType='float', r=True, w=True, h=False, k=True) cmds.connectAttr('spine_base_Control.Roll', 'spline_ik_handle.roll') cmds.select(FinalControl) cmds.addAttr(sn="tw", longName="Twist", attributeType='float', r=True, w=True, h=False, k=True) cmds.connectAttr('spine_final_Control.Twist', 'spline_ik_handle.twist') cmds.makeIdentity(apply=True, rotate=True, translate=True, scale=True)
def smooth_connectAttr(*args): ploy_n = cmd.ls(selection=True) cmd.select(cl=True) mel.eval("smoothRig") sm_ctrl = "smooth_ctrl" sm_ctrl_G = "smooth_ctrl_G" sm_ctrl_attr = "smooth_ctrl.smooth" HeadJoint_n = cmd.textFieldButtonGrp("s_UI_tfbg1", query=True, text=True) moveCtrl_n = cmd.textFieldButtonGrp("s_UI_tfbg2", query=True, text=True) cmd.parentConstraint(HeadJoint_n, sm_ctrl_G, weight=1, mo=1) cmd.parent(sm_ctrl_G, moveCtrl_n) if (len(ploy_n) == 0): print "请选择已经smooth模型" else: num = len(ploy_n) i = 1 for one in ploy_n: str_num = str(num) str_i = str(i) polySmooth_n = cmd.polySmooth(one, mth=0, sdt=2, ovb=1, ofb=3, ofc=0, ost=1, ocr=0, dv=1, bnr=1, c=1, kb=1, ksb=1, khe=0, kt=1, kmb=1, suv=1, peh=0, sl=1, dpe=1, ps=0.1, ro=1, ch=1) smooth_attr1 = polySmooth_n[0] + ".continuity" smooth_attr2 = polySmooth_n[0] + ".divisions" cmd.connectAttr(sm_ctrl_attr, smooth_attr1) cmd.connectAttr(sm_ctrl_attr, smooth_attr2) print("////完成smooth关联 " + str_i + " 个,共 " + str_num + " 个") i = i + 1 cmd.setAttr((sm_ctrl + ".tx"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".ty"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".tz"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".rx"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".ry"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".rz"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".sx"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".sy"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".sz"), lock=True, keyable=False, channelBox=False) cmd.setAttr((sm_ctrl + ".v"), lock=True, keyable=False, channelBox=False) cmd.select(cl=True) print "///////完成工作"
def mi_blinnToLambert(): sel_shaderType = cmds.textScrollList('ssitsl', q=True, si=True) if sel_shaderType == None: cmds.warning('no selected in textScrollList.') else: if sel_shaderType[0] != 'mi_blinn': return cmds.warning('Please select "mi_blinn" in the list.') mats = cmds.ls(type='mi_blinn') if len(mats): for single in mats: sg = cmds.listConnections('%s.outColor' % single, s=False, type='shadingEngine') if sg != None: lambertName = cmds.shadingNode('lambert', name=single, asShader=True) cmds.setAttr("%s.color" % lambertName, 1, 1, 1, type='double3') cmds.connectAttr('%s.outColor' % lambertName, '%s.surfaceShader' % sg[0], f=True) getShaderChannel(single, 'diffuse', lambertName, 'diffuse') getShaderChannel(single, 'transparency', lambertName, 'transparency') nc_all = cmds.connectionInfo('%s.normalCamera' % single, isDestination=True) if nc_all: d_all = cmds.listConnections('%s.normalCamera' % single, d=False, p=True)[0] ba = cmds.listConnections('%s.normalCamera' % single, d=False)[0] if cmds.listConnections('%s.bumpValue' % ba) != None: cmds.connectAttr(d_all, '%s.normalCamera' % lambertName, f=True) else: nc_x = cmds.connectionInfo('%s.normalCameraX' % single, isDestination=True) nc_y = cmds.connectionInfo('%s.normalCameraY' % single, isDestination=True) nc_z = cmds.connectionInfo('%s.normalCameraZ' % single, isDestination=True) if nc_x: d_x = cmds.listConnections('%s.normalCameraX' % single, d=False, p=True)[0] bx = cmds.listConnections('%s.normalCameraX' % single, d=False)[0] if cmds.listConnections('%s.bumpValue' % bx) != None: cmds.connectAttr(d_x, '%s.normalCameraX' % lambertName, f=True) if nc_y: d_y = cmds.listConnections('%s.normalCameraY' % single, d=False, p=True)[0] by = cmds.listConnections('%s.normalCameraY' % single, d=False)[0] if cmds.listConnections('%s.bumpValue' % by) != None: cmds.connectAttr(d_y, '%s.normalCameraY' % lambertName, f=True) if nc_z: d_z = cmds.listConnections('%s.normalCameraZ' % single, d=False, p=True)[0] bz = cmds.listConnections('%s.normalCameraZ' % single, d=False)[0] if cmds.listConnections('%s.bumpValue' % bz) != None: cmds.connectAttr(d_z, '%s.normalCameraZ' % lambertName, f=True) for ss in ['miShadowShader', 'miLightMapShader']: down = cmds.listConnections('%s.%s' % (sg[0], ss), d=False) if down != None: cmds.delete(down) else: print 'No (type : "mi_blinn") shaders in the scene!'
def anisymb(arg): errornum =[] sel =cmds.ls(sl=1) #print cmds.listAttr(r=1,channelBox=1) if sel!=[]: selall = cmds.listRelatives(sel[0],allDescendents=1) lsel =[] rsel=[] msel=[] allsel =[] pairblendnum =[] unvail =["Global"] spadj=["FKChest_M.rotateZ","FKNeck_M.rotateZ","","FKNeck_M.rotateY","FKChest_M.rotateY","FKRoot_M.rotateZ","FKRoot_M.rotateY","FKHead_M.rotateZ","FKHead_M.rotateY","FKSpine2_M.rotateZ","FKSpine2_M.rotateY","RootX_M.translateX","RootX_M.rotateZ","RootX_M.rotateY","lowerLid2_R.rotateZ","lowerLid2_L.rotateZ","lowerLid2_R.rotateY","lowerLid2_L.rotateY","lowerLid2_R.translateX","lowerLid2_L.translateX","lowerLid1_R.rotateZ","lowerLid1_L.rotateZ","lowerLid1_R.rotateY","lowerLid1_L.rotateY","lowerLid1_R.translateX","lowerLid1_L.translateX","lowerLid3_R.rotateZ","lowerLid3_L.rotateZ","lowerLid3_R.rotateY","lowerLid3_L.rotateY","lowerLid3_R.translateX","lowerLid3_L.translateX","LidCorner2_R.rotateZ","LidCorner2_L.rotateZ","LidCorner2_R.rotateY","LidCorner2_L.rotateY","LidCorner2_R.translateX","LidCorner2_L.translateX","upperLid3_R.rotateZ","upperLid3_L.rotateZ","upperLid3_R.rotateY","upperLid3_L.rotateY","upperLid3_R.translateX","upperLid3_L.translateX","upperLid1_R.rotateZ","upperLid1_L.rotateZ","upperLid1_R.rotateY","upperLid1_L.rotateY","upperLid1_R.translateX","upperLid1_L.translateX","upperLid2_R.rotateZ","upperLid2_L.rotateZ","upperLid2_R.rotateY","upperLid2_L.rotateY","upperLid2_R.translateX","upperLid2_L.translateX","LidCorner1_R.rotateZ","LidCorner1_L.rotateZ","LidCorner1_R.rotateY","LidCorner1_L.rotateY","LidCorner1_R.translateX","LidCorner1_L.translateX","browOuter_R.rotateZ","browOuter_L.rotateZ","browOuter_R.rotateY","browOuter_L.rotateY","browOuter_R.translateX","browOuter_L.translateX","browHalf_R.rotateZ","browHalf_L.rotateZ","browHalf_R.rotateY","browHalf_L.rotateY","browHalf_R.translateX","browHalf_L.translateX","browInner_R.rotateZ","browInner_L.rotateZ","browInner_R.rotateY","browInner_L.rotateY","browInner_R.translateX","browInner_L.translateX","noseCorner_R.rotateZ","noseCorner_L.rotateZ","noseCorner_R.rotateY","noseCorner_L.rotateY","noseCorner_R.translateX","noseCorner_L.translateX","lowerLip3_R.rotateZ","lowerLip3_L.rotateZ","lowerLip3_R.rotateY","lowerLip3_L.rotateY","lowerLip3_R.translateX","lowerLip3_L.translateX","upperLip3_R.R_rotateZ","upperLip3_R.L_rotateZ","upperLip3_R.R_rotateY","upperLip3_R.L_rotateY","upperLip3_R.R_translateX","upperLip3_R.L_translateX","Lip6_R.rotateZ","Lip6_L.rotateZ","Lip6_R.rotateY","Lip6_L.rotateY","Lip6_R.translateX","Lip6_L.translateX","cheek_R.rotateZ","cheek_L.rotateZ","cheek_R.rotateY","cheek_L.rotateY","cheek_R.translateX","cheek_L.translateX","FKScapula_R.translateY","FKScapula_L.translateY","FKScapula_R.translateX","FKScapula_L.translateX","FKScapula_R.translateZ","FKScapula_L.translateZ","IKArm_L.rotateY","IKArm_L.rotateZ","IKArm_R.rotateY","IKArm_R.rotateZ","IKLeg_L.rotateY","IKLeg_L.rotateZ","IKLeg_R.rotateY","IKLeg_R.rotateZ","IKArm_L.translateX","IKArm_R.translateX","IKLeg_L.translateX","IKLeg_R.translateX","IKLeg_L.swivel_foo","IKLeg_R.swivel_foot","PoleLeg_L.translateX","PoleLeg_R.translateX","PoleArm_R.translateX","PoleArm_L.translateX","Eyectrl_R.rotateY","Eyectrl_L.rotateY","RollToes_R.rotateY","RollToes_L.rotateY","RollToes_R.rotateZ","RollToes_L.rotateZ","RollToesEnd_L.rotateY","RollToesEnd_R.rotateY","RollToesEnd_L.rotateZ","RollToesEnd_R.rotateZ","RollHeel_R.rotateY","RollHeel_L.rotateY","RollHeel_R.rotateZ","RollHeel_L.rotateZ"] selsplit = sel[0].split(":") spacename = sel[0][0:(len(sel[0])-len(selsplit[-1]))] for i in range(len(selall)): cvshape = cmds.ls( selall[i],type="nurbsCurve") if cvshape!=[]: cvs = cmds.pickWalk(cvshape[0],d="up") # print cvs[0][len(spacename):-1] adj = cvs[0].split("_")[-1] if adj=="L": lsel.append(cvs[0]) allsel.append(cvs[0]) elif adj=="R": rsel.append(cvs[0]) allsel.append(cvs[0]) elif adj =="M": msel.append(cvs[0]) allsel.append(cvs[0]) for a in range(len(allsel)): allattrlist = cmds.listAttr(allsel[a],keyable=1,u=1) for t in range(len(allattrlist)): pbadj = cmds.listConnections( allsel[a]+"."+allattrlist[t],d=0,type="pairBlend") if pbadj!=None: pairblendnum.append(pbadj[0]) if len(pairblendnum)==0: if len(lsel) == len(rsel): for l in range(len(lsel)): attrlist = cmds.listAttr(lsel[l],keyable=1,u=1) ctrlname = lsel[l][0:(len(lsel[l])-1)] for a in range(len(attrlist)): if attrlist[a] not in unvail: lsrattradj = cmds.getAttr(ctrlname+"L"+"."+attrlist[a],lock=1) lattr = ctrlname+"L"+"."+attrlist[a] rsrattradj = cmds.getAttr(ctrlname+"R"+"."+attrlist[a],lock=1) rattr = ctrlname+"R"+"."+attrlist[a] if lsrattradj==False: # print lattr[len(spacename):] lattrAC = cmds.listConnections(lattr,d=0,type="animCurve") rattrAC = cmds.listConnections(rattr,d=0,type="animCurve") if lattrAC!=None: if rattrAC!=None: for c in range(len(lattrAC)): lattrACsin= cmds.listConnections(lattrAC[c],s=0,plugs=1)[0][len(spacename):] rattrACsin= cmds.listConnections(rattrAC[c],s=0,plugs=1)[0][len(spacename):] if cmds.isConnected(lattrAC[c]+".output",rattr)==False: cmds.connectAttr(lattrAC[c]+".output",rattr,f=1) if cmds.isConnected(rattrAC[c]+".output",lattr)==False: cmds.connectAttr(rattrAC[c]+".output",lattr,f=1) if lattrACsin in spadj: indexnum = cmds.keyframe( lattrAC[c], query=True, keyframeCount=True ) for i in range(indexnum): indexvalue = cmds.keyframe( lattrAC[0], query=True,index=(i,i),eval=1) newindexvalue = -float(indexvalue[0]) cmds.keyframe(lattrAC[0],index=(i,i),absolute=1,valueChange=float(newindexvalue)) if rattrACsin in spadj: rindexnum = cmds.keyframe( rattrAC[c], query=True, keyframeCount=True ) for r in range(rindexnum): rindexvalue = cmds.keyframe( rattrAC[0], query=True,index=(r,r),eval=1) rnewindexvalue = -float(rindexvalue[0]) cmds.keyframe(rattrAC[0],index=(r,r),absolute=1,valueChange=float(rnewindexvalue)) else: errornum.append(rattrAC) cmds.setKeyframe(rattr) else: errornum.append(lattrAC) cmds.setKeyframe(lattr) for m in range(len(msel)): attrlist = cmds.listAttr(msel[m],keyable=1,u=1) for a in range(len(attrlist)): if attrlist[a] not in unvail: mattradj = cmds.getAttr(msel[m]+"."+attrlist[a],lock=1) mattr = msel[m]+"."+attrlist[a] mattrAC = cmds.listConnections(mattr,d=0,type="animCurve") if mattrAC!=None: for c in range(len(mattrAC)): mattrACsin= cmds.listConnections(mattrAC[c],s=0,plugs=1)[0][len(spacename):] if cmds.isConnected(mattrAC[c]+".output",mattr)==False: cmds.connectAttr(mattrAC[c]+".output",mattr,f=1) if mattrACsin in spadj: mindexnum = cmds.keyframe( mattrAC[c], query=True, keyframeCount=True ) for i in range(mindexnum): mindexvalue = cmds.keyframe( mattrAC[0], query=True,index=(i,i),eval=1) mnewmindexvalue = -float(mindexvalue[0]) cmds.keyframe(mattrAC[0],index=(i,i),absolute=1,valueChange=float(mnewmindexvalue)) print "对称动画完成!", else: print "有约束属性,请烘焙该控制器的动画后解除约束,再进行操作!!",
def CreateConnectionsForShader(each, myshader): #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect color++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'color', myshader, 'color') #++++++++++++++++++++++++++++++++++++connect transparency++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'transparency', myshader, 'transparency') #++++++++++++++++++++++++++++++++++++connect ambientColor++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'ambientColor', myshader, 'ambientColor') ''' ambientColorlist=['%s.ambientColor'%each,'%s.ambientColorR'%each,'%s.ambientColorG'%each,'%s.ambientColorB'%each] alls=cmds.listConnections(ambientColorlist,d=False) if alls!=None: if cmds.nodeType(alls[0])=='mi_sss': ass=cmds.listConnections('%s.ambientColor'%each,d=False,p=True)[0] cmds.connectAttr (ass, '%s.sss'%myshader,f=True) else: getShaderChannel(each,'ambientColor',myshader,'ambientColor') else: number_r=cmds.getAttr('%s.ambientColorR'%each) number_g=cmds.getAttr('%s.ambientColorG'%each) number_b=cmds.getAttr('%s.ambientColorB'%each) cmds.setAttr('%s.ambientColor'%myshader, number_r, number_g, number_b ,type='double3') ''' #++++++++++++++++++++++++++++++++++++connect sss++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'sss', myshader, 'sss') #++++++++++++++++++++++++++++++++++++connect addSpecular++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'addSpecular', myshader, 'addSpecular') #++++++++++++++++++++++++++++++++++++connect addReflection++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'addReflection', myshader, 'addReflection') #++++++++++++++++++++++++++++++++++++connect ambientOcclusion++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'ambientOcclusion', myshader, 'ambientOcclusion') #++++++++++++++++++++++++++++++++++++connect worldNormal++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'worldNormal', myshader, 'worldNormal') #++++++++++++++++++++++++++++++++++++connect zdepth++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'zdepth', myshader, 'zdepth') #++++++++++++++++++++++++++++++++++++connect facingRatio++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'facingRatio', myshader, 'facingRatio') #++++++++++++++++++++++++++++++++++++connect mv++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'mv', myshader, 'mv') #++++++++++++++++++++++++++++++++++++connect assetObjectID++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'assetObjectID', myshader, 'assetObjectID') #++++++++++++++++++++++++++++++++++++connect materialID++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'materialID', myshader, 'materialID') #++++++++++++++++++++++++++++++++++++connect incandescence++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'incandescence', myshader, 'incandescence') #++++++++++++++++++++++++++++++++++++connect normalCamera++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ nc_all = cmds.connectionInfo('%s.normalCamera' % each, isDestination=True) if nc_all: d_all = cmds.listConnections('%s.normalCamera' % each, d=False, p=True)[0] cmds.connectAttr(d_all, '%s.normalCamera' % myshader, f=True) else: nc_x = cmds.connectionInfo('%s.normalCameraX' % each, isDestination=True) nc_y = cmds.connectionInfo('%s.normalCameraY' % each, isDestination=True) nc_z = cmds.connectionInfo('%s.normalCameraZ' % each, isDestination=True) if nc_x: d_x = cmds.listConnections('%s.normalCameraX' % each, d=False, p=True)[0] cmds.connectAttr(d_x, '%s.normalCameraX' % myshader, f=True) if nc_y: d_y = cmds.listConnections('%s.normalCameraY' % each, d=False, p=True)[0] cmds.connectAttr(d_y, '%s.normalCameraY' % myshader, f=True) if nc_z: d_z = cmds.listConnections('%s.normalCameraZ' % each, d=False, p=True)[0] cmds.connectAttr(d_z, '%s.normalCameraZ' % myshader, f=True) #++++++++++++++++++++++++++++++++++++connect diffuse++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'diffuse', myshader, 'diffuse') #++++++++++++++++++++++++++++++++++++connect translucence+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'translucence', myshader, 'translucence') #++++++++++++++++++++++++++++++++++++connect translucenceDepth+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'translucenceDepth', myshader, 'translucenceDepth') #++++++++++++++++++++++++++++++++++++connect translucenceFocus++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'translucenceFocus', myshader, 'translucenceFocus') #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect eccentricity++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'eccentricity', myshader, 'eccentricity') #++++++++++++++++++++++++++++++++++++connect specularRollOff++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'specularRollOff', myshader, 'specularRollOff') #++++++++++++++++++++++++++++++++++++connect specularColor++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'specularColor', myshader, 'specularColor') #++++++++++++++++++++++++++++++++++++connect reflectivity++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'reflectivity', myshader, 'reflectivity') #++++++++++++++++++++++++++++++++++++connect reflectedColor++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'reflectedColor', myshader, 'reflectedColor') #++++++++++++++++++++++++++++++++++++connect reflectionRolloff++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'reflectionRolloff', myshader, 'reflectionRolloff') #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect hideSource++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'hideSource', myshader, 'hideSource') #++++++++++++++++++++++++++++++++++++connect glowIntensity+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'glowIntensity', myshader, 'glowIntensity') #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect matteOpacityMode++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'matteOpacityMode', myshader, 'matteOpacityMode') #++++++++++++++++++++++++++++++++++++connect matteOpacity+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'matteOpacity', myshader, 'matteOpacity') #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect refractions+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'refractions', myshader, 'refractions') #++++++++++++++++++++++++++++++++++++connect refractiveIndex+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'refractiveIndex', myshader, 'refractiveIndex') #++++++++++++++++++++++++++++++++++++connect refractionLimit++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'refractionLimit', myshader, 'refractionLimit') #++++++++++++++++++++++++++++++++++++connect lightAbsorbance++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'lightAbsorbance', myshader, 'lightAbsorbance') #++++++++++++++++++++++++++++++++++++connect surfaceThickness+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'surfaceThickness', myshader, 'surfaceThickness') #++++++++++++++++++++++++++++++++++++connect shadowAttenuation++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'shadowAttenuation', myshader, 'shadowAttenuation') #++++++++++++++++++++++++++++++++++++connect chromaticAberration++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'chromaticAberration', myshader, 'chromaticAberration') #++++++++++++++++++++++++++++++++++++connect reflectionLimit+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'reflectionLimit', myshader, 'reflectionLimit') #++++++++++++++++++++++++++++++++++++connect reflectionSpecularity+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'reflectionSpecularity', myshader, 'reflectionSpecularity') #///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect miIrradiance++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miIrradiance', myshader, 'irradiance') #++++++++++++++++++++++++++++++++++++connect miIrradianceColor+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miIrradianceColor', myshader, 'irradianceColor') #++++++++++++++++++++++++++++++++++++connect miReflectionBlur++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miReflectionBlur', myshader, 'reflectionBlur') #++++++++++++++++++++++++++++++++++++connect miReflectionRays++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ try: getShaderChannel(each, 'miReflectionRays', myshader, 'reflectionRays') #++++++++++++++++++++++++++++++++++++connect miRefractionBlur++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miRefractionBlur', myshader, 'refractionBlur') #++++++++++++++++++++++++++++++++++++connect miRefractionRays++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miRefractionRays', myshader, 'refractionRays') #++++++++++++++++++++++++++++++++++++connect miScatterRadius+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterRadius', myshader, 'scatterRadius') #++++++++++++++++++++++++++++++++++++connect miScatterColor++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterColor', myshader, 'scatterColor') #++++++++++++++++++++++++++++++++++++connect miScatterAccuracy+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterAccuracy', myshader, 'scatterAccuracy') #++++++++++++++++++++++++++++++++++++connect miScatterFalloff+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterFalloff', myshader, 'scatterFalloff') #++++++++++++++++++++++++++++++++++++connect miScatterLimit++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterLimit', myshader, 'scatterLimit') #++++++++++++++++++++++++++++++++++++connect miScatterCache++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miScatterCache', myshader, 'scatterCache') #++++++++++++++++++++++++++++++++++++connect miReflectionBlurLimit++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miReflectionBlurLimit', myshader, 'reflectionBlurLimit') #++++++++++++++++++++++++++++++++++++connect miRefractionBlurLimit++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miRefractionBlurLimit', myshader, 'refractionBlurLimit') except: pass #////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #++++++++++++++++++++++++++++++++++++connect miFrameBufferWriteOperation++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miFrameBufferWriteOperation', myshader, 'FrameBufferWriteOperation') #++++++++++++++++++++++++++++++++++++connect miFrameBufferWriteFactor+++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miFrameBufferWriteFactor', myshader, 'FrameBufferWriteFactor') #++++++++++++++++++++++++++++++++++++connect miFrameBufferWriteFlags+++++++++++++++++++++++++++++++++++++++++++++++++++++++++ getShaderChannel(each, 'miFrameBufferWriteFlags', myshader, 'FrameBufferWriteFlags') cmds.delete(each)
def createdefault_mi_blinn(): shadername = mel.eval('mrCreateCustomNode -asShader "" mi_blinn') shadername_G = cmds.listConnections(shadername, s=0)[0] cmds.disconnectAttr('%s.message' % shadername, '%s.miMaterialShader' % shadername_G) #shadername_G=cmds.sets(renderable=True, noSurfaceShader=True, empty=True, name='%sSG'%shadername) cmds.connectAttr('%s.outColor' % shadername, '%s.surfaceShader' % shadername_G, f=True) bumpshader = cmds.shadingNode('bump2d', asUtility=True) cmds.connectAttr('%s.outNormal' % bumpshader, '%s.normalCamera' % shadername, f=True) shadowshader = mel.eval('mrCreateCustomNode -asUtility "" mayaShadow') cmds.connectAttr('%s.transparency' % shadername, '%s.transparency' % shadowshader, f=True) cmds.connectAttr('%s.shadowAttenuation' % shadername, '%s.shadowAttenuation' % shadowshader, f=True) cmds.connectAttr('%s.translucenceDepth' % shadername, '%s.translucenceDepth' % shadowshader, f=True) cmds.connectAttr('%s.outValue' % shadowshader, '%s.miShadowShader' % shadername_G, f=True) return shadername
def testAnimNurbsPlaneWrite(self, wfg=False): ret = MayaCmds.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=1, lr=1, d=3, u=5, v=5, ch=0) name = ret[0] MayaCmds.lattice(name, dv=(4, 5, 4), oc=True) MayaCmds.select('ffd1Lattice.pt[1:2][0:4][1:2]', r=True) MayaCmds.currentTime(1, update=True) MayaCmds.setKeyframe() MayaCmds.currentTime(24, update=True) MayaCmds.setKeyframe() MayaCmds.currentTime(12, update=True) MayaCmds.move( 0, 0.18, 0, r=True) MayaCmds.scale( 2.5, 1.0, 2.5, r=True) MayaCmds.setKeyframe() MayaCmds.curveOnSurface(name, uv=((0.597523,0), (0.600359,0.271782), (0.538598,0.564218), (0.496932,0.779936), (0.672153,1)), k=(0,0,0,0.263463,0.530094,0.530094,0.530094)) curvename = MayaCmds.curveOnSurface(name, uv=((0.170718,0.565967), (0.0685088,0.393034), (0.141997,0.206296), (0.95,0.230359), (0.36264,0.441381), (0.251243,0.569889)), k=(0,0,0,0.200545,0.404853,0.598957,0.598957,0.598957)) MayaCmds.closeCurve(curvename, ch=1, ps=1, rpo=1, bb=0.5, bki=0, p=0.1, cos=1) MayaCmds.trim(name, lu=0.23, lv=0.39) degreeU = MayaCmds.getAttr(name+'.degreeU') degreeV = MayaCmds.getAttr(name+'.degreeV') spansU = MayaCmds.getAttr(name+'.spansU') spansV = MayaCmds.getAttr(name+'.spansV') formU = MayaCmds.getAttr(name+'.formU') formV = MayaCmds.getAttr(name+'.formV') minU = MayaCmds.getAttr(name+'.minValueU') maxU = MayaCmds.getAttr(name+'.maxValueU') minV = MayaCmds.getAttr(name+'.minValueV') maxV = MayaCmds.getAttr(name+'.maxValueV') MayaCmds.createNode('surfaceInfo') MayaCmds.connectAttr(name+'.worldSpace', 'surfaceInfo1.inputSurface', force=True) MayaCmds.currentTime(1, update=True) controlPoints = MayaCmds.getAttr('surfaceInfo1.controlPoints[*]') knotsU = MayaCmds.getAttr('surfaceInfo1.knotsU[*]') knotsV = MayaCmds.getAttr('surfaceInfo1.knotsV[*]') MayaCmds.currentTime(12, update=True) controlPoints2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[*]') knotsU2 = MayaCmds.getAttr('surfaceInfo1.knotsU[*]') knotsV2 = MayaCmds.getAttr('surfaceInfo1.knotsV[*]') if wfg: self.__files.append(util.expandFileName('testAnimNurbsPlane.abc')) MayaCmds.AbcExport(j='-fr 1 24 -frs -0.25 -frs 0.0 -frs 0.25 -wfg -root %s -file %s' % (name, self.__files[-1])) # reading test MayaCmds.AbcImport(self.__files[-1], mode='open') else: self.__files.append(util.expandFileName('testAnimNurbsPlane.abc')) self.__files.append(util.expandFileName('testAnimNurbsPlane01_14.abc')) self.__files.append(util.expandFileName('testAnimNurbsPlane15_24.abc')) MayaCmds.AbcExport(j='-fr 1 14 -root %s -file %s' % (name, self.__files[-2])) MayaCmds.AbcExport(j='-fr 15 24 -root %s -file %s' % (name, self.__files[-1])) # use AbcStitcher to combine two files into one subprocess.call(self.__abcStitcher + self.__files[-3:]) # reading test MayaCmds.AbcImport(self.__files[-3], mode='open') self.failUnlessEqual(degreeU, MayaCmds.getAttr(name+'.degreeU')) self.failUnlessEqual(degreeV, MayaCmds.getAttr(name+'.degreeV')) self.failUnlessEqual(spansU, MayaCmds.getAttr(name+'.spansU')) self.failUnlessEqual(spansV, MayaCmds.getAttr(name+'.spansV')) self.failUnlessEqual(formU, MayaCmds.getAttr(name+'.formU')) self.failUnlessEqual(formV, MayaCmds.getAttr(name+'.formV')) self.failUnlessEqual(minU, MayaCmds.getAttr(name+'.minValueU')) self.failUnlessEqual(maxU, MayaCmds.getAttr(name+'.maxValueU')) self.failUnlessEqual(minV, MayaCmds.getAttr(name+'.minValueV')) self.failUnlessEqual(maxV, MayaCmds.getAttr(name+'.maxValueV')) MayaCmds.createNode('surfaceInfo') MayaCmds.connectAttr(name+'.worldSpace', 'surfaceInfo1.inputSurface', force=True) MayaCmds.currentTime(1, update=True) errmsg = "At frame #1, Nurbs Plane's control point #%d.%s not equal" for i in range(0, len(controlPoints)): cp1 = controlPoints[i] cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i)) self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x')) self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y')) self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z')) errmsg = "At frame #1, Nurbs Plane's control knotsU #%d not equal" for i in range(0, len(knotsU)): ku1 = knotsU[i] ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i)) self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i)) errmsg = "At frame #1, Nurbs Plane's control knotsV #%d not equal" for i in range(0, len(knotsV)): kv1 = knotsV[i] kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i)) self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i)) MayaCmds.currentTime(12, update=True) errmsg = "At frame #12, Nurbs Plane's control point #%d.%s not equal" for i in range(0, len(controlPoints2)): cp1 = controlPoints2[i] cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i)) self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x')) self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y')) self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z')) errmsg = "At frame #12, Nurbs Plane's control knotsU #%d not equal" for i in range(0, len(knotsU2)): ku1 = knotsU2[i] ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i)) self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i)) errmsg = "At frame #12, Nurbs Plane's control knotsV #%d not equal" for i in range(0, len(knotsV2)): kv1 = knotsV2[i] kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i)) self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i)) MayaCmds.currentTime(24, update=True) errmsg = "At frame #24, Nurbs Plane's control point #%d.%s not equal" for i in range(0, len(controlPoints)): cp1 = controlPoints[i] cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i)) self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x')) self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y')) self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z')) errmsg = "At frame #24, Nurbs Plane's control knotsU #%d not equal" for i in range(0, len(knotsU)): ku1 = knotsU[i] ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i)) self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i)) errmsg = "At frame #24, Nurbs Plane's control knotsV #%d not equal" for i in range(0, len(knotsV)): kv1 = knotsV[i] kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i)) self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i))
def create_mi_sssTo_mi_blinn(): mb = getSelectedMi_blinn() if mb == []: cmds.warning('no shaders {type : "mi_blinn"} were selected.') else: for single in mb: if cmds.listConnections('%s.sss' % single, d=False, type='mi_sss') != None: return mbg = cmds.listConnections(single, s=False, type='shadingEngine') if mbg == None: return misss = mel.eval('mrCreateCustomNode -asTexture "" mi_sss') sss_lmap = mel.eval( 'mrCreateCustomNode -asUtility "" misss_fast_lmap_maya') sss_texture = mel.eval( 'mrCreateCustomNode -asTexture "" mentalrayTexture') cmds.connectAttr('%s.message' % sss_texture, '%s.lightmap' % misss, f=True) cmds.connectAttr('%s.message' % sss_texture, '%s.lightmap' % sss_lmap, f=True) cmds.connectAttr('%s.message' % sss_lmap, '%s.miLightMapShader' % mbg[0], f=True) cmds.connectAttr('%s.outValue' % misss, '%s.sss' % single, f=True) nc_all = cmds.connectionInfo('%s.normalCamera' % single, isDestination=True) if nc_all: d_all = cmds.listConnections('%s.normalCamera' % single, d=False, p=True)[0] #print d_all if cmds.listConnections(d_all.split('.')[0], d=False) != None: cmds.connectAttr(d_all, '%s.normalCamera' % misss, f=True) else: nc_x = cmds.connectionInfo('%s.normalCameraX' % single, isDestination=True) nc_y = cmds.connectionInfo('%s.normalCameraY' % single, isDestination=True) nc_z = cmds.connectionInfo('%s.normalCameraZ' % single, isDestination=True) if nc_x: d_x = cmds.listConnections('%s.normalCameraX' % single, d=False, p=True)[0] cmds.connectAttr(d_x, '%s.normalCameraX' % misss, f=True) if nc_y: d_y = cmds.listConnections('%s.normalCameraY' % single, d=False, p=True)[0] cmds.connectAttr(d_y, '%s.normalCameraY' % misss, f=True) if nc_z: d_z = cmds.listConnections('%s.normalCameraZ' % single, d=False, p=True)[0] cmds.connectAttr(d_z, '%s.normalCameraZ' % misss, f=True) cmds.setAttr("%s.miWritable" % sss_texture, 1) cmds.setAttr("%s.miDepth" % sss_texture, 4) #mel.eval('expression -e -s "%s.miWidth = defaultResolution.width * 2" -o "" -ae 1 -uc all expression1'%sss_texture) #mel.eval('expression -e -s "%s.miHeight = defaultResolution.height" -o "" -ae 1 -uc all expression2'%sss_texture) cmds.expression(s="%s.miWidth=defaultResolution.width * 2" % sss_texture, o=sss_texture) cmds.expression(s="%s.miHeight = defaultResolution.height" % sss_texture, o=sss_texture)
def build_fkik(startJoint, endJoint, numJoints=6, scaleAttr='', blendCtrl='', blendAttr='stretchScale', prefix='cn_spine'): ''' Build a hybrid FK/IK spine rig @param startJoint: Start joint of the FK spine @type startJoint: str @param endJoint: End joint of the FK spine @type endJoint: str @param numJoints: Number of IK spine joints @type numJoints: int @param scaleAttr: Global character scale attribute @type scaleAttr: str @param blendCtrl: Control to store the spine stretch scale attribute @type blendCtrl: str @param blendAttr: Spine stretch scale attribute name @type blendAttr: str @param prefix: Name prefix for new nodes @type prefix: str ''' # ========== # - Checks - # ========== if not mc.objExists(startJoint): raise Exception('Start joint "' + startJoint + '" does not exist!') if not mc.objExists(endJoint): raise Exception('End joint "' + endJoint + '" does not exist!') if scaleAttr and not mc.objExists(scaleAttr): raise Exception('Scale attribute "' + scaleAttr + '" does not exist!') if blendCtrl and not mc.objExists(blendCtrl): raise Exception('Blend control "' + blendCtrl + '" does not exist!') # =================== # - Configure Spine - # =================== # IK curve fitRebuild = True curveSpans = 2 rebuildSpans = numJoints # Joint orient sideVector = [1, 0, 0] # IK stretch parametric = True scaleAxis = 'x' crvMin = 0.0 crvMax = 1.0 # IK twist ikTwistUpVec = 3 # Positive Z # Control scale fkCtrlScale = 1 ikCtrlScale = 0.5 # ========================== # - Build Module Structure - # ========================== # Create control group ctrl_grp = mc.group(n=prefix + '_ctrl_grp', w=True) # Create rig group rig_grp = mc.group(n=prefix + '_rig_grp', w=True) # Create skel group skel_grp = mc.group(n=prefix + '_skel_grp', w=True) # Create module group module = mc.group([ctrl_grp, rig_grp, skel_grp], n=prefix + '_module') # - Uniform Scale - mc.addAttr(module, ln='uniformScale', min=0.001, dv=1.0) mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleX') mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleY') mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleZ') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleX') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleY') mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleZ') # ===================== # - Create FK Joints - # ===================== # Get joint list spineJnts = glTools.utils.joint.getJointList(startJoint, endJoint) # For each joint spineJntGrps = [] for i in range(len(spineJnts) - 1): # Calculate joint length jntLen = glTools.utils.joint.length(spineJnts[i]) # Add control curves glTools.tools.controlBuilder.controlShape(spineJnts[i], 'square', rotate=[0, 90, 0], scale=jntLen * fkCtrlScale) # Add joint buffer jntGrp = glTools.utils.joint.group(spineJnts[i]) # Tag controls glTools.rig.utils.tagCtrl(spineJnts[i], 'primary') # Append list spineJntGrps.append(jntGrp) # Parent to ctrl grp mc.parent(spineJntGrps, ctrl_grp) # =================== # - Create IK Curve - # =================== # Build curve spineCurve = glTools.utils.curve.createFromPointList(spineJnts, degree=3, prefix=prefix) spineCurve = mc.rebuildCurve(spineCurve, ch=False, d=3, s=curveSpans, fr=fitRebuild, rpo=True, kr=0)[0] # Create curve locators spineLocs = glTools.utils.curve.locatorCurve(spineCurve, controlPoints=[], locatorScale=0.05, local=False, freeze=True, prefix=prefix) # Create rebuild curve ikRebuildCrv = mc.rebuildCurve(spineCurve, ch=True, d=3, s=rebuildSpans, rpo=False, kr=0) ikCurve = mc.rename(ikRebuildCrv[0], prefix + '_ik_curve') ikRebuild = mc.rename(ikRebuildCrv[1], prefix + '_ik_rebuildCurve') # Get Spine Length spineLen = mc.arclen(ikCurve) # Parent Spine Curve mc.parent(spineCurve, ikCurve, rig_grp) # ========================= # - Create Curve Controls - # ========================= # Initialize control builder ctrlBuilder = glTools.tools.controlBuilder.ControlBuilder() # - Create controls - # Base baseCtrl = ctrlBuilder.create('circle', prefix + '_base_ctrl', rotate=[90, 0, 0], scale=spineLen * ikCtrlScale) baseCtrlGrp = glTools.utils.base.group(baseCtrl, name=prefix + '_base_ctrlGrp') glTools.rig.utils.tagCtrl(baseCtrl, 'primary') # Mid midCtrl = ctrlBuilder.create('circle', prefix + '_mid_ctrl', rotate=[90, 0, 0], scale=spineLen * ikCtrlScale) midCtrlGrp = glTools.utils.base.group(midCtrl, name=prefix + '_mid_ctrlGrp') glTools.rig.utils.tagCtrl(midCtrl, 'primary') # Top topCtrl = ctrlBuilder.create('circle', prefix + '_top_ctrl', rotate=[90, 0, 0], scale=spineLen * ikCtrlScale) topCtrlGrp = glTools.utils.base.group(topCtrl, name=prefix + '_top_ctrlGrp') glTools.rig.utils.tagCtrl(topCtrl, 'primary') # Position controls pt = glTools.utils.base.getPosition(spineLocs[0]) mc.move(pt[0], pt[1], pt[2], baseCtrl, ws=True, a=True) pt = glTools.utils.base.getPosition(spineLocs[2]) mc.move(pt[0], pt[1], pt[2], midCtrl, ws=True, a=True) pt = glTools.utils.base.getPosition(spineLocs[-1]) mc.move(pt[0], pt[1], pt[2], topCtrl, ws=True, a=True) # Parent curve locators to controls mc.parent(spineLocs[:2], baseCtrl) mc.parent(spineLocs[2], midCtrl) mc.parent(spineLocs[3:], topCtrl) # Parent controls mc.parent(baseCtrlGrp, spineJnts[0]) mc.parent(midCtrlGrp, spineJnts[1]) mc.parent(topCtrlGrp, spineJnts[2]) # ==================== # - Create IK Joints - # ==================== # Create spine joints ikJnts = glTools.tools.createAlongCurve.create(curve=ikCurve, objType='joint', objCount=numJoints, parent=True, useDistance=True, minPercent=0.0, maxPercent=1.0, prefix=prefix + '_ik', suffix='jnt') # Orient Joints for jnt in ikJnts: glTools.utils.joint.orient(jnt, aimAxis='x', upAxis='z', upVec=sideVector) # ========================== # - Create Spine Top Joint - # ========================== # Create joint spineTopJoint = mc.joint(n=prefix + '_topA_jnt') spineTopJointGrp = glTools.utils.joint.group(spineTopJoint) # Attach joint mc.pointConstraint(ikJnts[-1], spineTopJointGrp, mo=False) mc.orientConstraint(topCtrl, spineTopJointGrp, mo=False) # ======================= # - Create Attach Joint - # ======================= mc.select(cl=True) # Create attach attachJoint = mc.joint(n=prefix + '_attachA_jnt') attachJointGrp = glTools.utils.joint.group(attachJoint) mc.delete(mc.parentConstraint(spineJnts[0], attachJointGrp)) # Attach joint display mc.setAttr(attachJoint + '.overrideEnabled', 1) mc.setAttr(attachJoint + '.overrideLevelOfDetail', 1) # Parent attach joint mc.parent([ikJnts[0], spineTopJointGrp], attachJoint) mc.parent(attachJointGrp, skel_grp) # ==================== # - Create IK Handle - # ==================== # Create ikHandle ikHandle = glTools.tools.ikHandle.build(ikJnts[0], ikJnts[-1], solver='ikSplineSolver', curve=ikCurve, ikSplineOffset=0.0, prefix=prefix) ikStretch = glTools.tools.stretchyIkSpline.stretchyIkSpline( ikHandle, parametric=parametric, scaleAxis=scaleAxis, scaleAttr=scaleAttr, blendControl=blendCtrl, blendAttr=blendAttr, minPercent=crvMin, maxPercent=crvMax, prefix=prefix) ikHandleGrp = glTools.utils.base.group(ikHandle, name=ikHandle + 'Grp') # Setup ikHandle Twist mc.setAttr(ikHandle + '.dTwistControlEnable', 1) mc.setAttr(ikHandle + '.dWorldUpType', 4) # Object Rotation Up mc.setAttr(ikHandle + '.dWorldUpAxis', ikTwistUpVec) mc.connectAttr(baseCtrl + '.worldMatrix[0]', ikHandle + '.dWorldUpMatrix', f=True) mc.connectAttr(topCtrl + '.worldMatrix[0]', ikHandle + '.dWorldUpMatrixEnd', f=True) mc.setAttr(ikHandle + '.dWorldUpVector', sideVector[0], sideVector[1], sideVector[2]) mc.setAttr(ikHandle + '.dWorldUpVectorEnd', sideVector[0], sideVector[1], sideVector[2]) # Parent ikHandle mc.parent(ikHandleGrp, rig_grp) # ====================== # - Set Channel States - # ====================== chStateUtil = glTools.utils.channelState.ChannelState() chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], objectList=spineJnts) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=spineJntGrps) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=spineLocs) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[spineCurve, ikCurve]) chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], objectList=[baseCtrl, midCtrl, topCtrl]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[baseCtrlGrp, midCtrlGrp, topCtrlGrp]) chStateUtil.setFlags([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], objectList=ikJnts) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[attachJointGrp]) chStateUtil.setFlags([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], objectList=[attachJoint]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[module, ctrl_grp, rig_grp, skel_grp]) # ================= # - Return Result - # ================= # Define control list ctrlList = spineJnts[:-1] ctrlList.append(baseCtrl) ctrlList.append(midCtrl) ctrlList.append(topCtrl) return [module, attachJoint]
def getShaderChannel(shaderName, channelname, generalname, newchannelname): if cmds.objExists('%s.%s' % (shaderName, channelname)) and cmds.objExists( '%s.%s' % (generalname, newchannelname)): e_all = cmds.objExists('%s.%s' % (shaderName, channelname)) e_r = cmds.objExists('%s.%sR' % (shaderName, channelname)) e_g = cmds.objExists('%s.%sG' % (shaderName, channelname)) e_b = cmds.objExists('%s.%sB' % (shaderName, channelname)) ci_all = cmds.connectionInfo('%s.%s' % (shaderName, channelname), isDestination=True) if e_all: if ci_all: all = cmds.listConnections('%s.%s' % (shaderName, channelname), d=False, p=True)[0] cmds.connectAttr(all, '%s.%s' % (generalname, newchannelname), f=True) else: if e_r: ci_r = cmds.connectionInfo('%s.%sR' % (shaderName, channelname), isDestination=True) if ci_r: r = cmds.listConnections('%s.%sR' % (shaderName, channelname), d=False, p=True)[0] cmds.connectAttr(r, '%s.%sR' % (generalname, newchannelname), f=True) if e_g: ci_g = cmds.connectionInfo('%s.%sG' % (shaderName, channelname), isDestination=True) if ci_g: g = cmds.listConnections('%s.%sG' % (shaderName, channelname), d=False, p=True)[0] cmds.connectAttr(g, '%s.%sG' % (generalname, newchannelname), f=True) if e_b: ci_b = cmds.connectionInfo('%s.%sB' % (shaderName, channelname), isDestination=True) if ci_b: b = cmds.listConnections('%s.%sB' % (shaderName, channelname), d=False, p=True)[0] cmds.connectAttr(b, '%s.%sB' % (generalname, newchannelname), f=True) if e_all == 1 and e_r == 1 and e_g == 1 and e_b == 1: if ci_all != 1 and ci_r != 1 and ci_g != 1 and ci_b != 1: number_r = cmds.getAttr('%s.%sR' % (shaderName, channelname)) number_g = cmds.getAttr('%s.%sG' % (shaderName, channelname)) number_b = cmds.getAttr('%s.%sB' % (shaderName, channelname)) cmds.setAttr('%s.%s' % (generalname, newchannelname), number_r, number_g, number_b, type='double3') if e_all == 1 and e_r != 1 and e_g != 1 and e_b != 1: if ci_all != 1: number = cmds.getAttr('%s.%s' % (shaderName, channelname)) if channelname == 'miReflectionBlur' or channelname == 'miRefractionBlur': number *= 0.01 cmds.setAttr('%s.%s' % (generalname, newchannelname), number)
def buildRibbonSpine(startJoint, endJoint, ribbonJoints, spans=0, ikSwitchCtrl='', ikSwitchAttr='spineIk', ctrlScale=1.0, prefix='cn_spine'): ''' ''' # ========== # - Checks - # ========== # Ribbon Joints for jnt in ribbonJoints: if not mc.objExists(jnt): raise Exception('Ribbon joint "' + jnt + '" does not exist!') # ==================== # - Build Spine Base - # ==================== # Get Joint List spineJnts = glTools.utils.joint.getJointList(startJoint, endJoint) spine = build(startJoint, endJoint, ikSwitchCtrl, ikSwitchAttr, ctrlScale, prefix) spine_module = spine[0] spine_attach = spine[1] spine_rig_grp = prefix + '_rig_grp' # ========================= # - Process Ribbon Joints - # ========================= for ribbonJoint in ribbonJoints: # Delete incoming connections mc.delete(mc.listConnections(ribbonJoint, s=True, d=False)) # ====================== # - Build Spine Ribbon - # ====================== locList = [] lfLocList = [] rtLocList = [] # Create Ribbon Locators for i in range(len(spineJnts)): pt = glTools.utils.base.getPosition(spineJnts[i]) strInd = glTools.utils.stringUtils.alphaIndex(i) loc = mc.spaceLocator(p=(0, 0, 0), n=prefix + strInd + '_loc')[0] lfLoc = mc.spaceLocator(p=(0.5, 0, 0), n=prefix + '_lf' + strInd + '_loc')[0] rtLoc = mc.spaceLocator(p=(-0.5, 0, 0), n=prefix + '_rt' + strInd + '_loc')[0] # Parent and position locators mc.parent([lfLoc, rtLoc], loc) mc.move(pt[0], pt[1], pt[2], loc, ws=True, a=True) mc.parent(loc, spineJnts[i]) mc.setAttr(loc + '.v', 0) # Append Lists locList.append(loc) lfLocList.append(lfLoc) rtLocList.append(rtLoc) # Create Loft Curves lfCurve = glTools.utils.curve.createFromLocators(lfLocList, degree=1, attach=True, prefix=prefix + 'A') rtCurve = glTools.utils.curve.createFromLocators(rtLocList, degree=1, attach=True, prefix=prefix + 'B') lfCurveShape = mc.listRelatives(lfCurve, s=True, pa=True)[0] rtCurveShape = mc.listRelatives(rtCurve, s=True, pa=True)[0] glTools.utils.shape.createIntermediate(lfCurveShape) glTools.utils.shape.createIntermediate(rtCurveShape) # Rebuild Loft Curves if not spans: spans = len(spineJnts) - 1 lfRebuildCrv = mc.rebuildCurve(lfCurve, ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=spans, d=3, tol=0) rtRebuildCrv = mc.rebuildCurve(rtCurve, ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=spans, d=3, tol=0) lfRebuildCrv = mc.rename(lfRebuildCrv[1], prefix + 'A_rebuildCurve') rtRebuildCrv = mc.rename(rtRebuildCrv[1], prefix + 'B_rebuildCurve') # Generate Loft Surface loft = mc.loft([lfCurve, rtCurve], d=1, n=prefix + '_surface') loftNode = mc.rename(loft[1], prefix + '_loft') spineSurface = loft[0] rebuildSrf = mc.rebuildSurface(spineSurface, ch=True, rpo=True, end=True, rt=0, kr=0, kcp=True, dir=2, du=1, dv=3) rebuildSrf = mc.rename(rebuildSrf[1], prefix + '_rebuildSurface') # Parent to rig group ribbonParts = [lfCurve, rtCurve, spineSurface] for ribbonPart in ribbonParts: mc.setAttr(ribbonPart + '.v', 0) mc.parent(ribbonPart, spine_rig_grp) # ======================== # - Attach Ribbon Joints - # ======================== inc = 1.0 / (len(ribbonJoints) - 1) ribbonJointGrps = [] for i in range(len(ribbonJoints)): # Create Joint Buffer Group strInd = glTools.utils.stringUtils.alphaIndex(i) prefix = glTools.utils.stringUtils.stripSuffix(ribbonJoints[i]) mc.select(cl=True) ribbonJointGrp = mc.joint(n=prefix + 'ConA_jnt') mc.delete(mc.pointConstraint(ribbonJoints[i], ribbonJointGrp)) ribbonJointGrps.append(ribbonJointGrp) # Attach Joint Buffer Group glTools.utils.attach.attachToSurface(spineSurface, ribbonJointGrp, useClosestPoint=True, orient=True, uAxis='y', vAxis='x', uAttr='uCoord', vAttr='vCoord', alignTo='v', prefix=prefix + strInd) # Parent Ribbon Joint mc.parent(ribbonJoints[i], ribbonJointGrp) mc.parent(ribbonJointGrp, spine_rig_grp) # Connect Module Scale mc.connectAttr(spine_module + '.uniformScale', ribbonJoints[i] + '.sx', f=True) mc.connectAttr(spine_module + '.uniformScale', ribbonJoints[i] + '.sy', f=True) mc.connectAttr(spine_module + '.uniformScale', ribbonJoints[i] + '.sz', f=True) # ====================== # - Set Channel States - # ====================== chStateUtil = glTools.utils.channelState.ChannelState() chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=locList) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=lfLocList) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=rtLocList) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=[lfCurve, rtCurve, spineSurface]) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=ribbonJoints) chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=ribbonJointGrps) # ================= # - Return Result - # ================= return [spine_module, spine_attach]
def publish(self, *args): result = cmds.confirmDialog(messageAlign="center", title="Publish Character", message="The action of publishing cannot be undone.\nAre you sure you wish to continue?",button=["Accept","Cancel"], defaultButton="Accept", cancelButton="Cancel", dismissString="Cancel") if result != "Accept": return result = cmds.promptDialog(title="Publish Character", message="Please specify a character name [a-z] [A-Z] and _ only: ", button=["Accept","Cancel"],defaultButton="Accept", cancelButton="Cancel", dismissString="Cancel") if result == "Accept": characterName = cmds.promptDialog(q=True, text=True) characterFileName = os.environ["RIGGING_TOOL_ROOT"]+"/Characters/"+characterName+".ma" if os.path.exists(characterFileName): cmds.confirmDialog(title="Publish Character", message="Character already exists with that name. Aborting Publish.", button=["Accept"], defaultButton="Accept") return cmds.lockNode("Scene_Locked", lock=False, lockUnpublished=False) cmds.delete("Scene_Locked") cmds.namespace(setNamespace=":") namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) moduleNameInfo = utils.findAllModuleNames("/Modules/Blueprint") validModules = moduleNameInfo[0] validModuleNames = moduleNameInfo[1] foundModuleInstances = [] for n in namespaces: splitString = n.partition("__") if splitString[1] != "": module = splitString[0] if module in validModuleNames: foundModuleInstances.append(n) moduleGroups = [] moduleContainers = [] for moduleInstance in foundModuleInstances: moduleGroups.append(moduleInstance+":module_grp") moduleContainers.append(moduleInstance+":module_container") for container in moduleContainers: cmds.lockNode(container, lock=False, lockUnpublished=False) characterGroup = cmds.group(empty=True, name="character_grp") for group in moduleGroups: cmds.parent(group, characterGroup, absolute=True) cmds.select(characterGroup, replace=True) cmds.addAttr(at="bool", defaultValue=0, keyable=False, longName="moduleMaintenanceVisibility") cmds.addAttr(at="bool", defaultValue=1, keyable=True, longName="animationControlVisibility") invertModuleMaintenanceVisibility = cmds.shadingNode("reverse", n="reverse_moduleMaintenanceVisibility", asUtility=True) cmds.connectAttr(characterGroup+".moduleMaintenanceVisibility", invertModuleMaintenanceVisibility+".inputX",force=True) moduleVisibilityMultiply = cmds.shadingNode("multiplyDivide", n="moduleVisibilityMultiply", asUtility=True) cmds.connectAttr(invertModuleMaintenanceVisibility+".outputX", moduleVisibilityMultiply+".input1X") cmds.connectAttr(characterGroup+".animationControlVisibility", moduleVisibilityMultiply+".input2X") characterNodes = list(moduleContainers) characterNodes.append(characterGroup) characterNodes.append(invertModuleMaintenanceVisibility) characterNodes.append(moduleVisibilityMultiply) characterContainer = cmds.container(name="character_container") utils.addNodeToContainer(characterContainer, characterNodes) cmds.container(characterContainer, edit=True, publishAndBind=[characterGroup+".animationControlVisibility", "animControlVis"]) for container in moduleContainers: moduleNamespace = utils.stripLeadingNamespace(container)[0] blueprintJointsGrp = moduleNamespace+":blueprint_joints_grp" cmds.connectAttr(characterGroup+".moduleMaintenanceVisibility", blueprintJointsGrp+".visibility") cmds.setAttr(blueprintJointsGrp+".overrideEnabled", 1) publishedNames = cmds.container(container, q=True, publishName=True) userSpecifiedName = moduleNamespace.partition("__")[2] for name in publishedNames: cmds.container(characterContainer, edit=True, publishAndBind=[container+"."+name, userSpecifiedName+"_"+name]) characterContainers = list(moduleContainers) characterContainers.append(characterContainer) cmds.select(all=True) topLevelTransforms = cmds.ls(sl=True, transforms=True) cmds.select(clear=True) topLevelTransforms.remove(characterGroup) if len(topLevelTransforms) != 0: nonBlueprintGroup = cmds.group(topLevelTransforms, absolute=True, parent=characterGroup, name="non_blueprint_grp") cmds.setAttr(nonBlueprintGroup+".overrideEnabled", 1) cmds.setAttr(nonBlueprintGroup+".overrideDisplayType", 2) #Reference display type cmds.select(nonBlueprintGroup, replace=True) cmds.addAttr(at="bool", defaultValue=1, longName="display", k=True) visibilityMultiply = cmds.shadingNode("multiplyDivide", n="non_blueprint_visibilityMultiply", asUtility=True) cmds.connectAttr(invertModuleMaintenanceVisibility+".outputX", visibilityMultiply+".input1X", force=True) cmds.connectAttr(nonBlueprintGroup+".display", visibilityMultiply+".input2X", force=True) cmds.connectAttr(visibilityMultiply+".outputX", nonBlueprintGroup+".visibility", force=True) nonBlueprintContainer = cmds.container(addNode=nonBlueprintGroup, ihb=True, includeNetwork=True, includeShapes=True, name="non_blueprint_container") utils.addNodeToContainer(characterContainer, nonBlueprintContainer) characterContainers.append(nonBlueprintContainer) publishedName = "displayNonBlueprintNodes" cmds.container(nonBlueprintContainer, edit=True, publishAndBind=[nonBlueprintGroup+".display", publishedName]) cmds.container(characterContainer, edit=True, publishAndBind=[nonBlueprintContainer+"."+publishedName, publishedName]) for container in characterContainers: cmds.lockNode(container, lock=True, lockUnpublished=True) cmds.select(characterContainer) cmds.file(characterFileName, exportSelected=True, type="mayaAscii") scenePublished = cmds.spaceLocator(n="Scene_Published")[0] cmds.setAttr(scenePublished+".visibility", 0) cmds.lockNode(scenePublished, lock=True, lockUnpublished=True) cmds.select(clear=True) cmds.button(self.UIElements["publishBtn"], edit=True, enable=False)