Example #1
0
    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)
Example #2
0
 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
Example #4
0
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
Example #5
0
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)
Example #6
0
 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)
Example #7
0
	def nucleus_(self, name = ''):
		nucleus = cmds.createNode('nucleus')
		if name:
			nucleus = cmds.rename(nucleus, name)
		cmds.connectAttr('time1.outTime', '%s.currentTime' % nucleus)

		return nucleus
Example #8
0
File: plug.py Project: hal1932/pm2
 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")
Example #10
0
 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)
Example #11
0
 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)
Example #12
0
    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()
Example #14
0
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
Example #15
0
	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))
Example #17
0
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 )
Example #19
0
 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
Example #20
0
 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!" )
Example #22
0
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)
Example #23
0
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
Example #25
0
 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 )
Example #26
0
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)
Example #27
0
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)
Example #28
0
 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)
Example #29
0
    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
Example #30
0
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 )
Example #31
0
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')
Example #34
0
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"
Example #35
0
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"
Example #36
0
    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()
Example #37
0
 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))
Example #38
0
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
Example #39
0
	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)
Example #40
0
    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])
Example #41
0
    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()
Example #42
0
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
Example #43
0
    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
Example #44
0
    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()
Example #45
0
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)
Example #46
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)
Example #47
0
    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 )
Example #48
0
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)
Example #50
0
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 "///////完成工作"
Example #51
0
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!'
Example #52
0
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 "有约束属性,请烘焙该控制器的动画后解除约束,再进行操作!!",
Example #53
0
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)
Example #54
0
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))
Example #56
0
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)
Example #57
0
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]
Example #58
0
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)
Example #59
0
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]
Example #60
0
	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)