def ik_stretch(ikhnd): ''' ''' jts = cmds.ikHandle(ikhnd, q=True, jl=True) cu_s = cmds.ikHandle(ikhnd, q=True, c=True) cu = cmds.listRelatives(cu_s, p=1)[0] cmds.addAttr(ikhnd, longName='ik_stretch', k=1, defaultValue=1.0, minValue=0.0, maxValue=1.) dcu = cmds.duplicate(cu, n=cu + '_base_scale')[0] dcu_s = cmds.listRelatives(dcu, c=1)[0] cf = cmds.createNode('curveInfo') dcf = cmds.createNode('curveInfo') bl = cmds.createNode('blendTwoAttr') md = cmds.createNode('multiplyDivide') cmds.connectAttr(cu_s + '.worldSpace', cf + '.inputCurve') cmds.connectAttr(dcu_s + '.worldSpace', dcf + '.inputCurve') cmds.connectAttr(dcf + '.arcLength', bl + '.input[0]') cmds.connectAttr(cf + '.arcLength', bl + '.input[1]') cmds.connectAttr(ikhnd + '.ik_stretch', bl + '.attributesBlender') cmds.connectAttr(bl + '.output', md + '.input1X') cmds.setAttr(md + '.input2X', cmds.getAttr(cf + '.arcLength'), l=1) cmds.setAttr(md + '.operation', 2) cmds.setAttr(dcu + '.v', 0) for j in jts: cmds.connectAttr(md + '.outputX', j + '.sx') return dcu
def addDefaultAttrState(objList): ''' Add a default attribute state multi attribute that will be used to store specified attribute values which can be restored on command. @param objList: List of objects to add the default attribute state multi attribute to. @type objList: list ''' # Check objList if not objList: return # Define defaultAttrState attribute name defAttr = 'defaultAttrState' # For each object in list attrList = [] for obj in objList: # Check Object if not mc.objExists(obj): raise Exception('Object "'+obj+'" does not exist!') # Check Attr if not mc.attributeQuery(defAttr,n=obj,ex=True): # Add attribute mc.addAttr(obj,ln=defAttr,dv=-1,m=True) attrList.append(obj+'.'+defAttr) else: print ('Object "'+obj+'" already has a "'+defAttr+'" attribute! Skipping...') # Return Result return attrList
def __init__(self, targets, base ): targets.append( base ) self._mainBlendShape = cmds.blendShape( *targets, n= base+'_mainBlendShape' )[0] cmds.addAttr( self._mainBlendShape, ln='isMainBlendShape', at='bool' )
def _create_functionality(self): ctl = self.get_control(0) attrs = ['heel', 'ball', 'tip', 'bankIn', 'bankOut'] for attr in attrs: cmds.addAttr(ctl.ctl, ln=attr, at="double", min=-10, max=10) cmds.setAttr("%s.%s" % (ctl.ctl, attr), cb=True) cmds.setAttr("%s.%s" % (ctl.ctl, attr), k=True) # Standard connections self.range_detail = {} for attr in attrs: sr = cmds.createNode("setRange", name=name.create_name(self.position, self.description, 0, "%sRange" % attr)) self.range_detail[attr] = sr # Create settings node connections for settings_attr in ['minX', 'maxX', 'oldMinX', 'oldMaxX']: titled_attr = re.sub('([a-zA-Z])', lambda k: k.groups()[0].upper(), settings_attr, 1) settings_full_attr = "%s.%s%s" % (self.setup_node, attr, titled_attr) cmds.addAttr(self.setup_node, ln="%s%s" % (attr, titled_attr), at="double") cmds.setAttr(settings_full_attr, cb=True) cmds.setAttr(settings_full_attr, k=True) cmds.connectAttr(settings_full_attr, "%s.%s" % (sr, settings_attr)) # Load settings for part if self.settings_file: log.debug("Settings file found! Loading...") key = os.path.splitext(os.path.basename(self.part_file))[0] data = SettingsFileHandler(key).read() for full_attr, value in data.items(): if cmds.objExists(full_attr): cmds.setAttr(full_attr, value) else: log.warning("No settnings file found, please create before continuing.")
def switch(node,attr,value=0,inputNames=list(),inputValues=list()): ''' :param node: :param attr: :param value: :param inputName: :param inputValues: :return: ''' attrName = "{0}.{1}".format(node,attr) choiceName = "{0}_{1}_switch".format(node,attr) cmds.createNode("choice",name=choiceName) cmds.addAttr(node,ln=attr,at="enum",en=":".join(inputNames),dv=value,keyable=True) for i in range(len(inputValues)): choiceAttr = "output{0}".format(i) cmds.addAttr(choiceName,ln=choiceAttr,at="double3") cmds.addAttr(choiceName,ln="{0}x".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][0]) cmds.addAttr(choiceName,ln="{0}y".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][1]) cmds.addAttr(choiceName,ln="{0}z".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][2]) cmds.connectAttr("{0}.{1}".format(choiceName,choiceAttr),"{0}.input[{1}]".format(choiceName,i)) cmds.connectAttr(attrName,"{0}.selector".format(choiceName),f=True) return "{0}.output".format(choiceName)
def addScalePP(particle): """ Add a per particle vector(Array) attribute named "scalePP", to the specified particle object. An initial state attribute "scalePP0" will also be created. @param particle: The particle or nParticle object to add the attribute to @type particle: str """ # Check Particle if not cmds.objExists(particle): raise Exception('Particle "' + particle + '" does not exist!') if cmds.objectType(particle) == 'transform': particleShape = cmds.listRelatives(particle, s=True) if not particleShape: raise Exception('Unable to determine particle shape from transform "' + particle + '"!') else: particle = particleShape[0] if (cmds.objectType(particle) != 'particle') and (cmds.objectType(particle) != 'nParticle'): raise Exception('Object "' + particle + '" is not a valid particle or nParticle object!') # Add rotatePP attribute if not cmds.objExists(particle + '.scalePP0'): cmds.addAttr(particle, ln='scalePP0', dt='vectorArray') if not cmds.objExists(particle + '.scalePP'): cmds.addAttr(particle, ln='scalePP', dt='vectorArray') # Return Result return particle + '.scalePP'
def stampCompiled(self, audioNodes): ''' Used by the compiler - stamp the audioNodes from which this audio track was compiled from ''' cmds.addAttr(self.audioNode, longName='compiledAudio', dt='string') cmds.setAttr('%s.compiledAudio' % self.audioNode, ','.join(audioNodes), type="string")
def addAttr( target, **options ): items = options.items() attrName = '' channelBox = False keyable = False for key, value in items: if key in ['ln', 'longName']: attrName = value elif key in ['cb', 'channelBox']: channelBox = True options.pop( key ) elif key in ['k', 'keyable']: keyable = True options.pop( key ) if cmds.attributeQuery( attrName, node=target, ex=1 ): return None cmds.addAttr( target, **options ) if channelBox: cmds.setAttr( target+'.'+attrName, e=1, cb=1 ) elif keyable: cmds.setAttr( target+'.'+attrName, e=1, k=1 )
def copy_user_attr(selparentshapes, seltargetshapes, copyUV=True): listattrvalue = {} listdatatype = {} userattr = cmds.listAttr(selparentshapes, ud=True) if copyUV and cmds.nodeType(seltargetshapes) == 'mesh' and cmds.nodeType(selparentshapes) == 'mesh': cmds.transferAttributes(selparentshapes, seltargetshapes, transferUVs=1, transferColors=2, searchMethod=3, sampleSpace=5, flipUVs=False) if userattr: for attr in userattr: nodetype = cmds.nodeType(selparentshapes) checkrendershape = cmds.getAttr(selparentshapes + '.intermediateObject') if checkrendershape != 1 or nodetype != 'mesh': key = attr value = cmds.getAttr("%s.%s" % (selparentshapes, key)) data = cmds.getAttr("%s.%s" % (selparentshapes, key), typ=True) listattrvalue[key] = value listdatatype[key] = data checkrendershape = cmds.getAttr(seltargetshapes + '.intermediateObject') if checkrendershape != 1: for key in listattrvalue: if not cmds.attributeQuery(key, node=seltargetshapes, ex=True): if listdatatype[key] == 'string': cmds.addAttr(seltargetshapes, longName=key, dataType=listdatatype[key]) cmds.setAttr("%s.%s" % (seltargetshapes, key), listattrvalue[key], type=listdatatype[key]) else: cmds.addAttr(seltargetshapes, longName=key) cmds.setAttr("%s.%s" % (seltargetshapes, key), listattrvalue[key]) else: cmds.warning('Attribute ' + key + ' already on ' + seltargetshapes) if cmds.getAttr("%s.%s" % (seltargetshapes, key), se=True): if listdatatype[key] == 'string': cmds.setAttr("%s.%s" % (seltargetshapes, key), listattrvalue[key], type=listdatatype[key]) else: cmds.setAttr("%s.%s" % (seltargetshapes, key), listattrvalue[key])
def create_base_rig(cog, rig_region_name): # create curve and scale it to the correct size base_curve, base_curve_group = jt_ctl_curve.create(None, 'star_30') cmds.select(base_curve) cmds.setAttr(base_curve + '.scale', 5,5,5) cmds.makeIdentity(apply=True, t=0, r=1, s=1, n=0) # unparent the curve from the default group it is given so its a child of the world base_curve = cmds.rename('base') cmds.parent(w=True) cmds.select(base_curve_group, r=True) cmds.delete() # add a string attribute to keep track of all the nodes that are used for easy de-rigging # NOTE: text is stored in the attr as a string formatted like a python dict with the key being # the name of the body region and the value being a list of the nodes involved this makes # de-rigging nice and easy as you just need to find the entry in the dict and delete all the nodes cmds.select(base_curve) cmds.addAttr(ln='rig_nodes', dt='string') cmds.setAttr(base_curve + '.rig_nodes', '{}', type='string') # add base_curve to base curve attr list add_node_to_rig_nodes(base_curve, 'base', base_curve) # update ui base_curve_field cmds.textField('jt_autorig_base_name_select_text', e=True, tx=base_curve)
def addRmanPrimVar(mesh,attrName,attrType='float',paintable=False): ''' ''' # Prefix attr attr = 'rmanF'+attrName # Data type if attrType == 'float': dataType = 'doubleArray' if attrType == 'vector': dataType = 'vectorArray' if attrType == 'string': dataType = 'stringArray' # Check mesh if not glTools.utils.mesh.isMesh(mesh): raise Exception('Mesh "'+mesh+'" does not exist!!') # Check attr if mc.objExists(mesh+'.'+attr): raise Exception('Attribute "'+mesh+'.'+attr+'" already exists!!') # Get shape meshShape = mc.listRelatives(mesh,s=True,ni=True,pa=True) if not meshShape: raise Exception('Unable to determine shape for mesh "'+mesh+'"!!') # Add attribute mc.addAttr(meshShape[0],ln=attr,dt=dataType) # Make paintable if paintable: mc.makePaintable('mesh',attr,attrType=dataType)
def save_scene(search_key, context, description, all_process): # add info about particular scene skey_link = 'skey://{0}&context={1}'.format(search_key, context) if not cmds.attributeQuery('tacticHandler_skey', node='defaultObjectSet', exists=True): cmds.addAttr('defaultObjectSet', longName='tacticHandler_skey', dataType='string') cmds.setAttr('defaultObjectSet.tacticHandler_skey', skey_link, type='string') # get template names for scene and playblast image temp_dir = env.Env().get_temp_dir() random_uuid = uuid.uuid4() types = { 'mayaBinary': 'mb', 'mayaAscii': 'ma', } temp_file = '{0}/{1}.ma'.format(temp_dir, random_uuid) temp_playblast = '{0}/{1}.jpg'.format(temp_dir, random_uuid) # rename file, save scene, playblast, get saving format cmds.file(rename=temp_file) cmds.file(save=True, type='mayaAscii') current_frame = cmds.currentTime(query=True) cmds.playblast( forceOverwrite=True, format='image', completeFilename=temp_playblast, showOrnaments=False, widthHeight=[960, 540], sequenceTime=False, frame=[current_frame], compression='jpg', offScreen=True, viewer=False, percent=100 ) # check in snapshot snapshot = tc.checkin_snapshot(search_key, context, temp_file, file_type='maya', is_current=True, description=description) # from pprint import pprint # pprint(snapshot) # retrieve checked in snapshot file info asset_dir = env.Env().get_asset_dir() file_sobject = snapshot['__file_sobjects__'][0] relative_dir = file_sobject['relative_dir'] file_name = file_sobject['file_name'] # make proper file path, and dir path to set workspace new_file = '{0}/{1}/{2}'.format(asset_dir, relative_dir, file_name) split_path = relative_dir.split('/') dir_path = '{0}/{1}'.format(asset_dir, '{0}/{1}/{2}'.format(*split_path)) set_workspace(dir_path, all_process) # check in playblast tc.checkin_playblast(snapshot['code'], temp_playblast) # set proper scene name cmds.file(rename=new_file)
def add_wf_mat_name_attr(*args): r'''addes a material name attribute of WFMaterialName based on diffuse file connection ''' mat_pairs=[] mats = cmds.ls(mat=True) for mat in mats: _file = cmds.listConnections('%s.color' % mat) if _file : tex_path = cmds.getAttr(_file[0] + '.fileTextureName') idx = tex_path.lower().find('assets') if idx != -1: new_name = '/' + tex_path[idx+7:-6] attr_list = cmds.listAttr(mat) if not ('WFMaterialName' in attr_list): print 'Attribute not in list, making attribute' cmds.addAttr(mat, dt="string", ln="WFMaterialName") cmds.setAttr(mat + '.WFMaterialName', new_name, type="string" ) # print ([mat, new_name]) mat_pairs.append([mat, new_name]) else: print 'Material: \n %s' % mat print 'String \"assets\" does not exist in the path\n %s' % tex_path return mat_pairs
def cleanup(self, version = 2.0): #hide groups and lock attributes cmds.setAttr(self.negativeBshpesGrp + ".v", 0) cmds.setAttr(self.resultBshpesGrp + ".v", 0) for i in cmds.ls(self.eTools, self.engineersToolsGrp, self.doNotTouchGrp, self.shotFinalGrp, self.mainBshpesGrp, self.negativeBshpesGrp, self.sculptBshpesGrp, self.resultBshpesGrp, "*Negative*", "*Sculpt*", "*Result*"): try: for axis in "xyz": cmds.setAttr(i + ".t" + axis, lock = 1, keyable = 0) cmds.setAttr(i + ".r" + axis, lock = 1, keyable = 0) cmds.setAttr(i + ".s" + axis, lock = 1, keyable = 0) cmds.setAttr(i + ".v", keyable = 0) cmds.setAttr(i + ".ihi", 0) except: pass #hide isHistoricallyInteresting for i in cmds.ls("blendShape*", "tweak*"): cmds.setAttr(i + ".ihi", 0) #add versionNumber of the SHOTFINAL script if not cmds.objExists(self.engineersToolsGrp + ".version"): cmds.addAttr(self.engineersToolsGrp, longName = "version", shortName = "version", attributeType = "float", keyable = 1) cmds.setAttr(self.engineersToolsGrp + ".version", version, edit = 1, channelBox = 1, lock = 1) #select the engineersTools group cmds.select(self.sculptTools)
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 add_target(self, name): cmds.select(self.main_jnt) jnt = cmds.joint(name=self.name + "_" + name + "_target_jnt") cmds.setAttr(jnt + ".t" + self.axis, 1.0) cmds.addAttr(jnt, ln="cone_angle", at="double", keyable=1, maxValue=360, minValue=0) cmds.addAttr(jnt, ln="pose_weight", at="double") norm_vp = cmds.createNode("vectorProduct", name=self.name + "_" + name + "normalize_vp") cmds.connectAttr(jnt + ".t", norm_vp + ".input1") cmds.setAttr(norm_vp + ".normalizeOutput", 1) cmds.setAttr(norm_vp + ".operation", 0) dot_vp = cmds.createNode("vectorProduct", name=self.name + "_" + name + "dot_vp") cmds.connectAttr(norm_vp + ".output", dot_vp + ".input1") cmds.connectAttr(self.reader_jnt + ".t", dot_vp + ".input2") cmds.setAttr(dot_vp + ".normalizeOutput", 1) angle_rv = cmds.createNode("remapValue", name=self.name + "_" + name + "_angle_rv") cmds.connectAttr(jnt + ".cone_angle", angle_rv + ".inputValue") cmds.setAttr(angle_rv + ".value[0].value_FloatValue", 1) cmds.setAttr(angle_rv + ".value[1].value_FloatValue", -1) cmds.setAttr(angle_rv + ".inputMax", 360.0) rv = cmds.createNode("remapValue", name=self.name + "_" + name + "_rv") # cmds.connectAttr(jnt + '.cone_angle', rv + '.value[0].value_Position') cmds.connectAttr(angle_rv + ".outValue", rv + ".value[0].value_Position") cmds.connectAttr(dot_vp + ".outputX", rv + ".inputValue") cmds.connectAttr(rv + ".outValue", jnt + ".pose_weight")
def add(self,objectList): ''' Adds the channel state attr to all specified objects @param objectList: List of objects to add flags to @type objectList: list ''' # Add Channel State Attrs for obj in objectList: # Check obj if not mc.objExists(obj): raise Exception('Object "'+obj+'" does not exist!') if not glTools.utils.transform.isTransform(obj): raise Exception('Object "'+obj+'" is not a valid transform!') if mc.objExists(obj+'.channelState'): print ('Object "'+obj+'" already has a "channelState" attribute! Skipping...') # Add channelState attr #mc.addAttr(obj,ln='channelState',at='enum',en=':Keyable:NonKeyable:Locked:',m=1,dv=-1) mc.addAttr(obj,ln='channelState',at='enum',en=':Keyable:NonKeyable:Locked:',m=1) # Set channelState flag values for i in range(len(self.channel)): if mc.getAttr(obj+'.'+self.channel[i],l=1): # Set Locked State mc.setAttr(obj+'.channelState['+str(i)+']',2) elif not mc.getAttr(obj+'.'+self.channel[i],k=1): # Set NonKeyable State mc.setAttr(obj+'.channelState['+str(i)+']',1) else: # Set Keyable State mc.setAttr(obj+'.channelState['+str(i)+']',0) # Alias Attribute mc.aliasAttr(self.channel[i]+'_state',obj+'.channelState['+str(i)+']')
def __add_root_attributes(self): #--- globalScale if not cmds.objExists(self.root + ".globalScale"): cmds.addAttr(self.root, longName="globalScale", min=0, defaultValue=1, attributeType='float') cmds.setAttr(self.root + '.globalScale', edit=True, keyable=False, channelBox=True) #--- project if not cmds.objExists(self.root + ".project"): cmds.addAttr(self.root, longName="project", dataType='string') cmds.setAttr(self.root + '.project', self.assetInfo[0], type='string', lock=True) #--- assetType if not cmds.objExists(self.root + ".assetType"): cmds.addAttr(self.root, longName="assetType", dataType='string') cmds.setAttr(self.root + '.assetType', self.assetInfo[1], type='string', lock=True) #--- assetResolution if not cmds.objExists(self.root + ".assetResolution"): cmds.addAttr(self.root, longName="assetResolution", dataType='string') cmds.setAttr(self.root + '.assetResolution', self.assetInfo[2], type='string', lock=True) #--- assetName if not cmds.objExists(self.root + ".assetName"): cmds.addAttr(self.root, longName="assetName", dataType='string') cmds.setAttr(self.root + '.assetName', self.assetInfo[3], type='string', lock=True)
def __cleanup(self, version = 2.0): #--- hide groups and lock attributes cmds.setAttr(self.negative_grp + '.v', 0) cmds.setAttr(self.result_grp + '.v', 0) sf_objs = cmds.ls(self.sf_tool, self.blendshapes, self.shotfinaling, self.mesh_bsp_grp, self.mesh_shotfinal_grp, self.negative_grp, self.sculpt_grp, self.result_grp, '*Negative*', '*Sculpt*', '*Result*', type = 'transform') for i in sf_objs: for axis in 'xyz': cmds.setAttr(i + '.t' + axis, lock = 1, keyable = 0) cmds.setAttr(i + '.r' + axis, lock = 1, keyable = 0) cmds.setAttr(i + '.s' + axis, lock = 1, keyable = 0) cmds.setAttr(i + '.v', keyable = 0) cmds.setAttr(i + '.ihi', 0) #--- hide isHistoricallyInteresting to_ihi = cmds.ls('*BSP*', '*Bshpe*', '*tweak*', '*Shape*') for i in sf_objs: to_ihi.append(i) for i in to_ihi: cmds.setAttr(i + '.ihi', 0) #--- add versionNumber of the SHOTFINAL script if not cmds.objExists(self.shotfinaling + '.version'): cmds.addAttr(self.shotfinaling, longName = 'version', shortName = 'version', attributeType = 'float', keyable = True) cmds.setAttr(self.shotfinaling + '.version', version, edit = True, channelBox = True, lock = True) #--- select the sculpt tool cmds.select(self.sculpt_tool)
def combine(self, objs=[], new_name="", keepHistory=0): ''' Combines the geometry and stores the names. This is useful for speeding up the rigs and seperating in a predictible way. @param objs: Mesh objects to combine @type objs: list @param new_name: New name for the combined mesh @type new_name: str @param keepHistory: Maintain history after function has completed @type keepHistory: bool ''' # Check input arguments if not objs: raise Exception('Input list "objs" is not a valid list!') for obj in objs: if not mc.objExists(obj): raise Exception('Object '+obj+' does not exist!') if mc.objExists(new_name): raise Exception('An object of name '+new_name+' already exists! Please choose another name!') # Combine multiple mesh objects to a single mesh new_obj = mc.polyUnite(objs, n=new_name) mc.addAttr( new_obj[0], ln='origNames', dt='string', multi=True) # Recond original names list on new mesh transform for i in range(len(objs)): mc.setAttr( new_obj[0]+'.origNames['+str(i)+']', objs[i], type='string') # Delete history if not keepHistory : mc.delete(new_obj[1]) mc.delete(objs) return new_obj[0]
def add_long(node, kwargs): """Long attribute""" attr = kwargs["ln"] if _safe_attr(node, attr): full = "%s.%s" % (node, attr) cmds.addAttr(node, **kwargs) return full
def pyToAttr(objAttr, data): """ Write (pickle) Python data to the given Maya obj.attr. This data can later be read back (unpickled) via attrToPy(). Arguments: objAttr : string : a valid object.attribute name in the scene. If the object exists, but the attribute doesn't, the attribute will be added. The if the attribute already exists, it must be of type 'string', so the Python data can be written to it. data : some Python data : Data that will be pickled to the attribute in question. """ obj, attr = objAttr.split('.') # Add the attr if it doesn't exist: if not cmds.objExists(objAttr): cmds.addAttr(obj, longName=attr, dataType='string') # Make sure it is the correct type before modifing: if cmds.getAttr(objAttr, type=True) != 'string': raise Exception("Object '%s' already has an attribute called '%s', but it isn't type 'string'"%(obj,attr)) # Pickle the data and return the coresponding string value: stringData = cPickle.dumps(data) # Make sure attr is unlocked before edit: cmds.setAttr(objAttr, edit=True, lock=False) # Set attr to string value: cmds.setAttr(objAttr, stringData, type='string') # And lock it for safety: cmds.setAttr(objAttr, edit=True, lock=True)
def _create_meta_data(self): """ Creates a network node to hold the meta data for the rig. """ network_node = cmds.createNode("network") meta_node_name = self._get_unique_name("metaNode", "DyMETA") meta_node = cmds.rename(network_node, meta_node_name) data = { "rootGroup" : self.root_group, "rigName" : self.rig_name, "parentControl" : self.parent_control, "controls" : self.controls, "pointLock" : self.point_lock, "startFrame" : self.start_frame, "endFrame" : self.end_frame, "dynamicControl" : self.dynamic_control, "metaNode" : meta_node, "hairSystem" : self.hair_system} # build data for meta, data in data.iteritems(): if meta == "controls": cmds.addAttr(meta_node, dt="stringArray", ln=meta) cmds.setAttr("{0}.{1}".format(meta_node, meta), *([len(data)]+data), type="stringArray") continue cmds.addAttr(meta_node, dt="string", ln=meta) cmds.setAttr("{0}.{1}".format(meta_node, meta), data, type="string")
def createAssetSetFromSelect(name = 'asset1', type = ''): asset = mc.sets(name = "%s" % name) mc.addAttr(asset, longName = 'asset', niceName = "Asset", dataType = 'string') mc.addAttr(asset, longName = 'type', niceName = "Type", dataType = 'string') mc.setAttr("%s.asset" % asset, name, type = "string") mc.setAttr("%s.type" % asset, type, type = "string") return asset
def addSymEdgeAttr(edge): ''' Add mesh symmetry edge attribute based on specified mesh edge. @param edge: Mesh edge that defined the center edge row of a symmetrical mesh @type edge: str ''' # Check Edge edge = mc.filterExpand(edge,ex=True,sm=32) or [] if not edge: raise Exception('No valid mesh edge selected!') if len(edge) > 1: print('Multiple mesh edges found! Using first edge only ("'+edge[0]+'").') edge = edge[0] # Get Edge Mesh mesh = mc.ls(edge,o=True) or [] if not mesh: raise Exception('Unable to determine mesh from edge!') if len(mesh) > 1: print('Multiple mesh objects found from edge!') mesh = mesh[0] # Get Edge ID edgeID = glTools.utils.component.index(edge) # Add Attribute symAttr = 'symmetryEdgeId' if not mc.objExists(mesh+'.'+symAttr): mc.addAttr(mesh,ln=symAttr,at='long',min=0,dv=edgeID) mc.setAttr(mesh+'.'+symAttr,edgeID) # Return Result return mesh+'.'+symAttr
def rsChangeCheck(i_b_state, i_s_floatField): if i_s_floatField == "rsMinField": i_b_state = cmds.checkBox("rsMinBox", query=True, value=True) else: i_b_state = cmds.checkBox("rsMaxBox", query=True, value=True) l_oSels = rsObjList() if i_b_state == True: if i_s_floatField == "rsMinField": b_minimum = cmds.attributeQuery(l_oSels[1], node=l_oSels[0], minExists=True) f_atValue = 0.0 if b_minimum == 1: f_atValue = (cmds.attributeQuery(l_oSels[1], node=l_oSels[0], minimum=True))[0] else: cmds.addAttr(l_oSels[2], edit=True, hasMinValue=True) if i_s_floatField == "rsMaxField": b_maximum = cmds.attributeQuery(l_oSels[1], node=l_oSels[0], maxExists=True) f_atValue = 1.0 if b_maximum == 1: f_atValue = (cmds.attributeQuery(l_oSels[1], node=l_oSels[0], maximum=True))[0] else: cmds.addAttr(l_oSels[2], edit=True, hasMaxValue=True) cmds.addAttr(l_oSels[2], edit=True, maxValue=f_atValue) cmds.floatField(i_s_floatField, edit=True, value=f_atValue, enable=True) else: cmds.floatField(i_s_floatField, edit=True, value=0, enable=False) if i_s_floatField == "rsMinField": cmds.addAttr(l_oSels[2], edit=True, hasMinValue=False) else: cmds.addAttr(l_oSels[2], edit=True, hasMaxValue=False) return True
def rsChName(i_s_textField, s_name): l_oSels = rsObjList() i_LockState = cmds.getAttr(l_oSels[2], lock=True) if i_LockState: cmds.setAttr(l_oSels[2], lock=False) if s_name == "NewName": s_NewName = l_oSels[0] + "." + i_s_textField cmds.renameAttr(l_oSels[2], i_s_textField) if i_LockState: cmds.setAttr(s_NewName, lock=True) s_search = i_s_textField else: cmds.addAttr(l_oSels[2], edit=True, niceName=i_s_textField) if i_LockState: cmds.setAttr(l_oSels[2], lock=True) s_search = l_oSels[1] l_ChannelAtList = rsChannelAtList() l_AttrKey = l_ChannelAtList[0] l_AttrKeyHidden = l_ChannelAtList[1] if l_AttrKey or l_AttrKeyHidden: cmds.textScrollList("rsAttributeScroll", edit=True, removeAll=True, append=l_AttrKey) cmds.textScrollList("rsAttributeScrollHidden", edit=True, removeAll=True, append=l_AttrKeyHidden) cmds.select(cl=True) cmds.select(l_oSels[0], r=True) rsSearchInScroll(s_search) return True
def addIdAttr(self,*args): selList = self.listSelected() meshList = self.getMeshList(selList) # add attribute to selected meshes for mesh in meshList: if not mc.objExists(mesh+'.'+self.idGroupAttr): mc.addAttr(mesh,ln = self.idGroupAttr,sn = self.idGroupAttr,at = "long",dv = -1)
def createGuide(self, *args): Base.StartClass.createGuide(self) # Custom GUIDE: cmds.addAttr(self.moduleGrp, longName="flip", attributeType='bool') cmds.setAttr(self.moduleGrp+".flip", 0) cmds.addAttr(self.moduleGrp, longName="indirectSkin", attributeType='bool') cmds.setAttr(self.moduleGrp+".indirectSkin", 0) cmds.setAttr(self.moduleGrp+".moduleNamespace", self.moduleGrp[:self.moduleGrp.rfind(":")], type='string') self.cvJointLoc, shapeSizeCH = ctrls.cvJointLoc(ctrlName=self.guideName+"_JointLoc1", r=0.3) self.connectShapeSize(shapeSizeCH) self.jGuide1 = cmds.joint(name=self.guideName+"_JGuide1", radius=0.001) cmds.setAttr(self.jGuide1+".template", 1) cmds.parent(self.jGuide1, self.moduleGrp, relative=True) self.cvEndJoint, shapeSizeCH = ctrls.cvLocator(ctrlName=self.guideName+"_JointEnd", r=0.1) self.connectShapeSize(shapeSizeCH) cmds.parent(self.cvEndJoint, self.cvJointLoc) cmds.setAttr(self.cvEndJoint+".tz", 1.3) self.jGuideEnd = cmds.joint(name=self.guideName+"_JGuideEnd", radius=0.001) cmds.setAttr(self.jGuideEnd+".template", 1) cmds.transformLimits(self.cvEndJoint, tz=(0.01, 1), etz=(True, False)) ctrls.setLockHide([self.cvEndJoint], ['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']) cmds.parent(self.cvJointLoc, self.moduleGrp) cmds.parent(self.jGuideEnd, self.jGuide1) cmds.parentConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ParentConstraint") cmds.parentConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ParentConstraint") cmds.scaleConstraint(self.cvJointLoc, self.jGuide1, maintainOffset=False, name=self.jGuide1+"_ScaleConstraint") cmds.scaleConstraint(self.cvEndJoint, self.jGuideEnd, maintainOffset=False, name=self.jGuideEnd+"_ScaleConstraint")
def updateOrigNamesFormat(self,objectList=[]): ''' Update a combined meshes origNames attribute to the newest format. @param objectList: list of mesh objects to update origNames attribute on. @type objectList: list ''' # Confirm list if type(objectList) == str: objectList = [objectList] # Iterate through object list for obj in objectList: # Check origNames attribute if not mc.objExists(obj+'.origNames'): raise Exception('Object '+obj+' does not have a "origNames" attribute!') if mc.addAttr(obj+'.origNames',q=True,multi=True): print(obj+'.origNames is already in the correct format.') continue # Extract original names list from old format origNamesList = [] index = 0 while True: if mc.objExists(obj+'.origNames.origNames_'+str(index)): origNamesList.append(mc.getAttr(obj+'.origNames.origNames_'+str(index))) index+=1 else: break # Re-create the origNames attribute in the new format mc.deleteAttr(obj+'.origNames') mc.addAttr(obj,ln='origNames',dt='string',multi=True) for i in range(len(origNamesList)): mc.setAttr( obj+'.origNames['+str(i)+']', origNamesList[i], type='string')
def setupBlueprintWeightBasedBlending(self): settingsLocator = self.blueprintNamespace + ":SETTINGS" attributes = cmds.listAttr(settingsLocator, keyable=False) weightAttributes = [] for attr in attributes: if attr.find("_weight") != -1: weightAttributes.append(attr) value = 0 if len(weightAttributes) == 0: value = 1 cmds.setAttr(settingsLocator + ".creationPoseWeight", 0) cmds.select(settingsLocator) weightAttributeName = self.moduleNamespace + "_weight" cmds.addAttr(ln=weightAttributeName, at="double", min=0, max=1, defaultValue=value, keyable=False) cmds.container(self.blueprintNamespace + ":module_container", edit=True, publishAndBind=[ settingsLocator + "." + weightAttributeName, weightAttributeName ]) currentEntries = cmds.attributeQuery("activeModule", n=settingsLocator, listEnum=True) newEntry = self.moduleNamespace if currentEntries[0] == "None": cmds.addAttr(settingsLocator + ".activeModule", edit=True, enumName=newEntry) cmds.setAttr(settingsLocator + ".activeModule", 0) else: cmds.addAttr(settingsLocator + ".activeModule", edit=True, enumName=currentEntries[0] + ":" + newEntry) utilityNodes = [] for i in range(1, len(self.joints)): joint = self.joints[i] nameSuffix = utils.stripAllNamespaces(joint)[1] blueprintJoint = self.blueprintNamespace + ":blueprint_" + nameSuffix weightNodeAttr = settingsLocator + "." + weightAttributeName if i < len(self.joints) - 1 or len(self.joints) == 2: multiplyRotations = cmds.shadingNode( "multiplyDivide", n=joint + "_multiplyRotationsWeight", asUtility=True) utilityNodes.append(multiplyRotations) cmds.connectAttr(joint + ".rotate", multiplyRotations + ".input1", force=True) for attr in ["input2X", "input2Y", "input2Z"]: cmds.connectAttr(weightNodeAttr, multiplyRotations + "." + attr, force=True) index = utils.findFirstFreeConnection(blueprintJoint + "_addRotations.input3D") cmds.connectAttr( multiplyRotations + ".output", blueprintJoint + "_addRotations.input3D[" + str(index) + "]") if i == 1: addNode = blueprintJoint + "_addTranslate" if cmds.objExists(addNode): multiplyTranslation = cmds.shadingNode( "multiplyDivide", n=joint + "_multiplyTranslationWeight", asUtility=True) utilityNodes.append(multiplyTranslation) cmds.connectAttr(joint + ".translate", multiplyTranslation + ".input1", force=True) for attr in ["input2X", "input2Y", "input2Z"]: cmds.connectAttr(weightNodeAttr, multiplyTranslation + "." + attr, force=True) index = utils.findFirstFreeConnection(addNode + ".input3D") cmds.connectAttr(multiplyTranslation + ".output", addNode + ".input3D[" + str(index) + "]", force=True) addNode = blueprintJoint + "_addScale" #I am removing the following lines to eliminate scale for now. if cmds.objExists(addNode): multiplyScale = cmds.shadingNode("multiplyDivide", n=joint + "_multiplyScaleWeight", asUtility=True) utilityNodes.append(multiplyScale) cmds.connectAttr(joint + ".scale", multiplyScale + ".input1", force=True) for attr in ["input2X", "input2Y", "input2Z"]: cmds.connectAttr(weightNodeAttr, multiplyScale + "." + attr, force=True) index = utils.findFirstFreeConnection(addNode + ".input3D") cmds.connectAttr(multiplyScale + ".output", addNode + ".input3D[" + str(index) + "]", force=True) else: multiplyTranslation = cmds.shadingNode( "multiplyDivide", n=joint + "_multiplyTranslationWeight", asUtility=True) utilityNodes.append(multiplyTranslation) cmds.connectAttr(joint + ".translateX", multiplyTranslation + ".input1X", force=True) cmds.connectAttr(weightNodeAttr, multiplyTranslation + ".input2X", force=True) addNode = blueprintJoint + "_addTx" index = utils.findFirstFreeConnection(addNode + ".input1D") cmds.connectAttr(multiplyTranslation + ".outputX", addNode + ".input1D[" + str(index) + "]", force=True) return utilityNodes
def create(self, renderMeshes=None, rootJoint=None, strName='uExport'): uExport = None if cmds.objExists(strName): #later re-hook up #set uExport pass else: uExport = cmds.group(em=1, name=strName) cmds.addAttr(uExport, ln='rendermesh', at='message') cmds.addAttr(uExport, ln='export_root', at='message') cmds.addAttr(uExport, ln='materials', at='message') cmds.addAttr(uExport, ln='uexport_ver', dt='string') cmds.setAttr(uExport + '.uexport_ver', '1.0', type='string') cmds.addAttr(uExport, ln='folder_path', dt='string') cmds.addAttr(uExport, ln='asset_name', dt='string') cmds.addAttr(uExport, ln='fbx_name', dt='string') if uExport: try: if renderMeshes: self.connectRenderMeshes(uExport, renderMeshes, rewire=0) #rootJoint if rootJoint: if not attrExists(rootJoint + '.export'): cmds.addAttr(rootJoint, longName='export', attributeType='message') cmds.connectAttr(rootJoint + '.export', uExport + '.export_root') else: cmds.warning('No root joint or could not find root: ' + str(rootJoint)) except Exception as e: print cmds.warning(e)
def braidGen(): allSel = cmds.ls(sl=1) for eachCurve in allSel: cmds.select(eachCurve) mel.eval('makeCurvesDynamic 2 { "1", "1", "1", "1", "0"}') #First Step nHair - Make Curves Dynamic follicle = cmds.listConnections(eachCurve) follicleShape = cmds.listRelatives(follicle[0], shapes=1) follicleBraid = follicleShape[0] + ".braid" follicleSampleDensity = follicleShape[0] + ".sampleDensity" cmds.setAttr(follicleBraid, 1) # Set Braid to be TRUE cmds.setAttr(follicleSampleDensity, 100) # Set SampleDensity to be smoother cmds.select(eachCurve) #print $follicleShape; hairSystem = cmds.listConnections(follicleShape[0], type='hairSystem') hairSystemShape = cmds.listRelatives(hairSystem[0], type='hairSystem') #string $hairSystemShape[] = `ls -type hairSystem`; for i in range(0, len(hairSystemShape)): if i != 0: hairSystemShape.pop(i) mainGroup = eachCurve + "_HairSystemGrp" #print $hairSystemShape; cmds.group(hairSystemShape[0], n=mainGroup) NucleusList = cmds.listConnections(hairSystemShape[0], type='nucleus') thisNucleus = NucleusList[0] cmds.parent(thisNucleus, mainGroup) cmds.select(eachCurve) hairSystemShapeLastNum = len(hairSystemShape) hairSystemShapeClumpCount = hairSystemShape[hairSystemShapeLastNum - 1] + ".hairsPerClump" hairSystemShapeClumpWidth = hairSystemShape[hairSystemShapeLastNum - 1] + ".clumpWidth" hairSystemShapeClumpTaper = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[1].clumpWidthScale_FloatValue" hairSystemShapeClumpFlatness = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpFlatness[0].clumpFlatness_FloatValue" hairSystemShapeClumpCount = hairSystemShape[hairSystemShapeLastNum - 1] + ".hairsPerClump" ClumpWidthScale_pos1 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[0].clumpWidthScale_Position" ClumpWidthScale_val1 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[0].clumpWidthScale_FloatValue" ClumpWidthScale_pos2 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[1].clumpWidthScale_Position" ClumpWidthScale_val2 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[1].clumpWidthScale_FloatValue" ClumpWidthScale_pos3 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[2].clumpWidthScale_Position" ClumpWidthScale_val3 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[2].clumpWidthScale_FloatValue" ClumpWidthScale_pos4 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[3].clumpWidthScale_Position" ClumpWidthScale_val4 = hairSystemShape[ hairSystemShapeLastNum - 1] + ".clumpWidthScale[3].clumpWidthScale_FloatValue" cmds.setAttr(ClumpWidthScale_pos1, 0) cmds.setAttr(ClumpWidthScale_val1, 0) cmds.setAttr(ClumpWidthScale_pos2, 0.001) cmds.setAttr(ClumpWidthScale_val2, 1) cmds.setAttr(ClumpWidthScale_pos3, 0.999) cmds.setAttr(ClumpWidthScale_val3, 1) cmds.setAttr(ClumpWidthScale_pos4, 0.999) cmds.setAttr(ClumpWidthScale_val4, 0) cmds.setAttr(hairSystemShapeClumpCount, 3) cmds.setAttr(hairSystemShapeClumpWidth, 3) mel.eval("AssignBrushToHairSystem;") pfxHair = cmds.listConnections(hairSystemShape[hairSystemShapeLastNum - 1]) pfxHair_Size = len(pfxHair) pfxHairLast = pfxHair[pfxHair_Size - 1] cmds.parent(pfxHairLast, mainGroup) cmds.select(pfxHairLast) # select last one mel.eval("doPaintEffectsToCurve(1);") pfxHairStringCount = len(pfxHairLast) pfxHairLastNum = pfxHairLast[7:pfxHairStringCount] pfxHairShapeCurves = "pfxHairShape" + pfxHairLastNum + "Curves" cmds.parent(pfxHairShapeCurves, mainGroup) follicleConnectedCurve = cmds.listConnections(follicleShape[0], type='nurbsCurve') for originCurve in follicleConnectedCurve: objects = cmds.ls(originCurve, l=1) parentList = [] parentList = objects[0].split("|") cmds.parent(parentList[1], mainGroup) cmds.select(pfxHairShapeCurves) getList = ldmt_tubeGen.tubeGen(eachCurve) Tubes = cmds.ls(sl=1) cmds.select(eachCurve) Tube0_LengthDiv = Tubes[0] + ".lengthDivisions" Tube1_LengthDiv = Tubes[1] + ".lengthDivisions" Tube2_LengthDiv = Tubes[2] + ".lengthDivisions" Tube0_WidthDiv = Tubes[0] + ".widthDivisions" Tube1_WidthDiv = Tubes[1] + ".widthDivisions" Tube2_WidthDiv = Tubes[2] + ".widthDivisions" Tube0_Width = Tubes[0] + ".width" Tube1_Width = Tubes[1] + ".width" Tube2_Width = Tubes[2] + ".width" Tube0_Taper = Tubes[0] + ".taper" Tube1_Taper = Tubes[1] + ".taper" Tube2_Taper = Tubes[2] + ".taper" lengthDivisionsControl = eachCurve + ".lengthDivisions" widthDivisionsControl = eachCurve + ".widthDivisions" braidWidthControl = eachCurve + ".braidWidth" braidTaperControl = eachCurve + ".braidTaper" flatnessControl = eachCurve + ".flatness" perbraidWidthControl = eachCurve + ".perbraidWidth" perBraidTaperControl = eachCurve + ".perbraidtaper" if cmds.attributeQuery("braidWidth", node=eachCurve, ex=1): cmds.deleteAttr(lengthDivisionsControl) cmds.deleteAttr(widthDivisionsControl) cmds.deleteAttr(braidWidthControl) cmds.deleteAttr(braidTaperControl) cmds.deleteAttr(flatnessControl) cmds.deleteAttr(perbraidWidthControl) cmds.deleteAttr(perBraidTaperControl) cmds.addAttr(eachCurve, min=0, ln="braidWidth", h=0, k=1, at='double', dv=1) cmds.addAttr(eachCurve, min=0, ln="braidTaper", h=0, k=1, at='double', dv=1) cmds.addAttr(eachCurve, ln="flatness", h=0, k=1, at='double', max=1, dv=0) cmds.addAttr(eachCurve, min=0, ln="lengthDivisions", h=0, k=1, at='long', dv=100) cmds.addAttr(eachCurve, min=0, ln="widthDivisions", h=0, k=1, at='long', dv=7) cmds.addAttr(eachCurve, min=0, ln="perbraidWidth", h=0, k=1, at='double', dv=0.5) cmds.addAttr(eachCurve, min=0, ln="perbraidtaper", h=0, k=1, at='double', dv=1) cmds.expression(s=(hairSystemShapeClumpWidth + "=" + braidWidthControl)) cmds.expression(s=(hairSystemShapeClumpTaper + "=" + braidTaperControl)) cmds.expression(s=(hairSystemShapeClumpFlatness + "=" + flatnessControl)) cmds.expression(s=(Tube0_LengthDiv + "=" + lengthDivisionsControl)) cmds.expression(s=(Tube1_LengthDiv + "=" + lengthDivisionsControl)) cmds.expression(s=(Tube2_LengthDiv + "=" + lengthDivisionsControl)) cmds.expression(s=(Tube0_WidthDiv + "=" + widthDivisionsControl)) cmds.expression(s=(Tube1_WidthDiv + "=" + widthDivisionsControl)) cmds.expression(s=(Tube2_WidthDiv + "=" + widthDivisionsControl)) cmds.expression(s=(Tube0_Width + "=" + perbraidWidthControl)) cmds.expression(s=(Tube1_Width + "=" + perbraidWidthControl)) cmds.expression(s=(Tube2_Width + "=" + perbraidWidthControl)) cmds.expression(s=(Tube0_Taper + "=" + perBraidTaperControl)) cmds.expression(s=(Tube1_Taper + "=" + perBraidTaperControl)) cmds.expression(s=(Tube2_Taper + "=" + perBraidTaperControl)) cmds.hide(mainGroup) cmds.parent(eachCurve, w=1, r=1) cmds.parent(mainGroup, eachCurve) cmds.parent(getList[0], eachCurve) cmds.parent(getList[1], eachCurve) cmds.select(Tubes) ldmt_fixReverse.fixReverse() cmds.select(allSel) for i in allSel: cmds.rename(i, 'Braid_#')
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.parent(TP.attach_list, 'attach_GRP') cmds.parent(TP.noneTrans_list, 'noneTransform_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, 'templateJoint_GRP', TP.hide_list ) #cmds.HideSelectedObjects () ### Rotate controler self.controlerRotate(TP.rotate_con_list_A, 0, 0, -90) self.controlerRotate(TP.rotate_con_list_B, -90, 0, 0)
def CreateFeet(): l_arrow = base.curve(p = [(1,0,0),(1,0,2), (2,0,2),(0,0,6), (-2,0,2), (-1,0,2), (-1,0,0), (1,0,0)], degree = 1, name = "CTRL_L_Foot") base.addAttr(shortName = "KF", longName = "Knee_Twist", attributeType = 'double', defaultValue = 0, minValue = -100, maxValue = 100, keyable = True) base.addAttr(shortName = "KR", longName = "Knee_Fix", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) base.addAttr(shortName = "FR", longName = "Foot_Roll", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) base.addAttr(shortName = "BR", longName = "Ball_Roll", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) r_arrow = base.curve(p = [(1,0,0),(1,0,2), (2,0,2),(0,0,6), (-2,0,2), (-1,0,2), (-1,0,0), (1,0,0)], degree = 1, name = "CTRL_R_Foot") base.addAttr(shortName = "KF", longName = "Knee_Twist", attributeType = 'double', defaultValue = 0, minValue = -100, maxValue = 100, keyable = True) base.addAttr(shortName = "KR", longName = "Knee_Fix", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) base.addAttr(shortName = "FR", longName = "Foot_Roll", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) base.addAttr(shortName = "BR", longName = "Ball_Roll", attributeType = 'double', defaultValue = 0, minValue = 0, maxValue = 100, keyable = True) base.scale(0.08, 0.08, 0.08, l_arrow) base.scale(0.08, 0.08, 0.08, r_arrow) l_footPos = base.xform(base.ls("RIG_L_Foot"), q = True, t = True, ws = True) r_footPos = base.xform(base.ls("RIG_R_Foot"), q = True, t = True, ws = True) base.move(l_footPos[0], 0, l_footPos[2], l_arrow) base.move(r_footPos[0], 0, r_footPos[2], r_arrow) base.makeIdentity(l_arrow, apply = True, t = 1, r = 1, s = 1) base.makeIdentity(r_arrow, apply = True, t = 1, r = 1, s = 1) base.parent(l_arrow, "MASTER_CONTROLLER") base.parent(r_arrow, "MASTER_CONTROLLER")
def install_init(self): cmds.namespace(setNamespace=self.blueprintNamespace) cmds.namespace(add=self.moduleNamespace) cmds.namespace(setNamespace=":") characterContainer = self.characterNamespaceOnly + ":character_container" blueprintContainer = self.blueprintNamespace + ":module_container" containers = [characterContainer, blueprintContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) # Duplicate creation pose joints to create new instance. Stored in external method. self.joints = self.duplicateAndRenameCreationPose() moduleJointsGrp = self.joints[0] # Group everything for animation module and parent to "Hook_IN_Grp" moduleGrp = cmds.group(empty=True, name=self.blueprintNamespace + ":" + self.moduleNamespace + ":module_grp") hookIn = self.blueprintNamespace + ":HOOK_IN" cmds.parent(moduleGrp, hookIn, relative=True) cmds.parent(moduleJointsGrp, moduleGrp, absolute=True) # Attr to define icon size. cmds.select(moduleGrp) cmds.addAttr(at="float", ln="iconScale", min=0.001, softMaxValue=10.0, defaultValue=1, k=True) cmds.setAttr(moduleGrp + ".overrideEnabled", 1) cmds.setAttr(moduleGrp + ".overrideColor", 6) utilityNodes = self.setupBlueprintWeightBasedBlending() self.setupModuleVisibility(moduleGrp) containedNodes = list(self.joints) containedNodes.append(moduleGrp) containedNodes.extend(utilityNodes) self.moduleContainer = cmds.container(n=self.moduleContainer) utils.addNodeToContainer(self.moduleContainer, containedNodes, ihb=True) utils.addNodeToContainer(blueprintContainer, self.moduleContainer) #151 index = 0 publishToOuterContainers = False for joint in self.joints: if index > 0: niceJointName = utils.stripAllNamespaces(joint)[1] self.publishNameToModuleContainer( joint + ".rotate", niceJointName + "_R", publishToOuterContainers=False) publishToOuterContainers = False index += 1 self.publishNameToModuleContainer(moduleGrp + ".lod", "Control_LOD") self.publishNameToModuleContainer(moduleGrp + ".iconScale", "Icon_Scale") self.publishNameToModuleContainer(moduleGrp + ".overrideColor", "Icon_Color") self.publishNameToModuleContainer(moduleGrp + ".visibility", "Vis") self.publishNameToModuleContainer(moduleGrp + ".visibility", "Vis", publishToOuterContainers=False) return (self.joints, moduleGrp, self.moduleContainer)
def uninstall(self): characterContainer = self.characterNamespaceOnly + ":character_container" blueprintContainer = self.blueprintNamespace + ":module_container" moduleContainer = self.moduleContainer # Unlock containers containers = [characterContainer, blueprintContainer, moduleContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) containers.pop() blueprintJointsGrp = self.blueprintNamespace + ":blueprint_joints_grp" blueprintJoints = utils.findJointChain(blueprintJointsGrp) blueprintJoints.pop(0) settingsLocator = self.blueprintNamespace + ":SETTINGS" connections = cmds.listConnections(blueprintJoints[0] + "_addRotations", source=True, destination=False) if len(connections) == 2: cmds.setAttr(blueprintJointsGrp + ".controlModulesInstalled", False) publishedNames = cmds.container(moduleContainer, q=True, publishName=True) publishedNames.sort() for name in publishedNames: outerPublishedNames = cmds.container(characterContainer, q=True, publishName=True) if name in outerPublishedNames: cmds.container(characterContainer, edit=True, unbindAndUnpublish=blueprintContainer + "." + name) cmds.container(blueprintContainer, edit=True, unbindAndUnpublish=moduleContainer + "." + name) cmds.delete(moduleContainer) weightAttributeName = self.moduleNamespace + "_weight" cmds.deleteAttr(settingsLocator + "." + weightAttributeName) attributes = cmds.listAttr(settingsLocator, keyable=False) weightAttributes = [] for attr in attributes: if attr.find("_weight") != -1: weightAttributes.append(attr) totalWeight = 0 for attr in weightAttributes: totalWeight += cmds.getAttr(settingsLocator + "." + attr) cmds.setAttr(settingsLocator + ".creationPoseWeight", 1 - totalWeight) currentEntries = cmds.attributeQuery("activeModule", n=settingsLocator, listEnum=True) currentEntriesList = currentEntries[0].split(":") ourEntry = self.moduleNamespace currentEntriesString = "" for entry in currentEntriesList: if entry != ourEntry: currentEntriesString += entry + ":" if currentEntriesString == "": currentEntriesString = "None" cmds.addAttr(settingsLocator + ".activeModule", edit=True, enumName=currentEntriesString) cmds.setAttr(settingsLocator + ".activeModule", 0) cmds.namespace(setNamespace=self.blueprintNamespace) cmds.namespace(removeNamespace=self.moduleNamespace) cmds.namespace(setNamespace=":") for c in containers: cmds.lockNode(c, lock=True, lockUnpublished=True)
def importPointCloudX(self, filePath): """ Read data from file - old method. Kept here for completeness. """ if os.path.isfile(filePath): # Check file exists # Read data into numpy array data = np.genfromtxt(filePath) count = data.shape[0] # Initialise progress bar and start timer mc.progressBar(self.gMainProgressBar, edit=True, beginProgress=True, isInterruptable=True, maxValue=count) # Initialise progress bar startTime = time.time() # Create group and particles etc. fileName = os.path.splitext(os.path.basename(filePath))[0] pCloudGroup = mc.group(name="%s_pointCloud_GRP" % fileName, empty=True) pCloudParticle = mc.particle(name="pCloud_%s" % fileName) #mel.eval('addAttr -ln "rgbPP" -dt vectorArray %s' %pCloudParticle[1]) #mel.eval('addAttr -ln "rgbPP0" -dt vectorArray %s' %pCloudParticle[1]) mc.addAttr(pCloudParticle[1], longName="rgbPP", dataType="vectorArray") mc.addAttr(pCloudParticle[1], longName="rgbPP0", dataType="vectorArray") for i in range(count): # # Progress bar # if mc.progressBar(self.gMainProgressBar, query=True, isCancelled=True): # Cancel operation if esc key pressed # mc.progressBar(self.gMainProgressBar, edit=True, endProgress=True) # Complete progress bar # mc.warning("Operation interrupted. You may wish to undo.") # return False # else: # mc.progressBar(self.gMainProgressBar, edit=True, step=1, status="Generating point cloud...") # Increment progress bar pX = data[i, 0] pY = data[i, 1] pZ = data[i, 2] pR = data[i, 3] / 255.0 pG = data[i, 4] / 255.0 pB = data[i, 5] / 255.0 # xyz = data[i,0:3] # rgb = data[i,3:6]/255 mel.eval('emit -o %s -at "rgbPP" -pos %s %s %s -vv %s %s %s' % (pCloudParticle[0], pX, pY, pZ, pR, pG, pB)) #mc.emit(object=pCloudParticle[0], position=xyz, attribute="rgbPP", vectorValue=rgb) mc.saveInitialState(pCloudParticle[0]) mc.setAttr("%s.isDynamic" % pCloudParticle[1], 0) mc.parent(pCloudParticle[0], pCloudGroup) # Complete progress bar and end clock mc.progressBar(self.gMainProgressBar, edit=True, endProgress=True) # Complete progress bar totalTime = time.time() - startTime print "Read %d points in %f seconds.\n" % (count, totalTime) return pCloudGroup else: mc.error("File doesn't exist: %s" % filePath) return False
def publish(self, settings, item): """ Executes the publish logic for the given item and settings. :param settings: Dictionary of Settings. The keys are strings, matching the keys returned in the settings property. The values are `Setting` instances. :param item: Item to process """ publisher = self.parent # get the path to create and publish publish_path = item.properties["path"] # ensure the publish folder exists: publish_folder = os.path.dirname(publish_path) self.parent.ensure_folder_exists(publish_folder) # set the alembic args that make the most sense when working with Mari. # These flags will ensure the export of an USD file that contains # all visible geometry from the current scene together with UV's and # face sets for use in Mari. usd_args = [ '-shd "none"', '-dms "none"', '-uvs 1', '-cls 0', '-vis 1', '-mt 0', '-sl', #'-fs %f'%item.properties['sub_frame'], '-ft %f' % item.properties['sub_frame'] ] # find the animated frame range to use: start_frame, end_frame = _find_scene_animation_range() if start_frame and end_frame: usd_args.append("-fr %d %d" % (start_frame, end_frame)) # Set the output path: # Note: The AbcExport command expects forward slashes! usd_args.append('-f "%s"' % publish_path.replace("\\", "/")) # build the export command. Note, use AbcExport -help in Maya for # more detailed USD export help usd_export_cmd = ("usdExport %s" % " ".join(usd_args)) # ...and execute it: try: self.parent.log_debug("Executing command: %s" % usd_export_cmd) select_list = [ x for x in cmds.listRelatives( item.properties['name'], c=1, f=1, ad=1) if not x.find("cache_grp") == -1 and x.find("cache_grp|") == -1 ] for obj in select_list: if not cmds.attributeQuery("USD_kind", node=obj, exists=True): cmds.addAttr(obj, longName="USD_kind", dataType="string") cmds.setAttr(obj + ".USD_kind", "component", type="string") cmds.select(select_list) _to_tractor(self, item, usd_export_cmd) #mel.eval(usd_export_cmd) except Exception, e: import traceback print usd_export_cmd self.parent.log_debug("Executing command: %s" % usd_export_cmd) self.logger.error("Failed to export USD: %s" % e, extra={ "action_show_more_info": { "label": "Error Details", "tooltip": "Show the full error stack trace", "text": "<pre>%s</pre>" % (traceback.format_exc(), ) } }) return
def create(self): self._lBpCtrlsSpine = self._lBpCtrls self._lBpCtrls = [self._lBpCtrlsPelvis[1]] + self._lBpCtrls sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sRig' %(self._sPart, self._sNameRig), 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._sNameRig), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl) sGrpNode = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sNode' %(self._sPart, self._sNameRig), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sGrpNode) self._sConnectInJnt = sGrp self._sConnectInCtrl = sGrpCtrl self._sGrpNode = sGrpNode super(spineRig, self).create() ## fk rig oSpineFk = fkJointChainRig.fkJointChainRig( sName = 'Fk', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex, lBpJnts = self._lBpCtrlsSpine, sConnectInCtrl = self._sConnectInCtrl, sConnectInJnt = self._sConnectInJnt, bSub = self._bSub, iStacks = self._iStacks, lLockHideAttrs = self._lLockHideAttrs) oSpineFk.create() ## pelvis rig oPelvisFk = fkJointChainRig.fkJointChainRig( sName = 'Fk', sSide = self._sSide, sPart = self._sPartPelvis, iIndex = self._iIndex, lBpJnts = self._lBpCtrlsPelvis, sConnectInCtrl = self._sConnectInCtrl, sConnectInJnt = self._sConnectInJnt, bSub = self._bSub, iStacks = self._iStacks, lLockHideAttrs = self._lLockHideAttrs ) oPelvisFk.create() ## ik spline oSpineIk = ikSplineRig.ikSplineRig( sName = 'ikSpline', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex, lBpJnts = self._lBpCtrls, sConnectInCtrl = self._sConnectInCtrl, sConnectInJnt = self._sConnectInJnt, sGrpNode = self._sGrpNode, bSub = self._bSub, iStacks = self._iStacks, lLockHideAttrs = self._lLockHideAttrs, lBpCtrls = self._lBpCtrlsSpine[:-1], bOrientTop = True, bOrientBot = True, lCtrlOrient = self._lCtrlOrient, ) oSpineIk.create() ## constraint and hidde ribbon controls for i, sCtrl in enumerate(self._lCtrls): oCtrl = controls.oControl(sCtrl) cmds.parentConstraint(oSpineIk.lJnts[i], oCtrl.sPasser, mo = False) cmds.setAttr('%s.v' %oCtrl.sPasser, 0) ## constraint ik controls ## pelvis oCtrl = controls.oControl(oSpineIk.lCtrls[0]) constraints.constraint([oPelvisFk.lJnts[0], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True) ## spine for i, sCtrl in enumerate(oSpineIk.lCtrls[1:]): oCtrl = controls.oControl(sCtrl) if i == 0: constraints.constraint([oSpineFk.lJnts[i], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True) else: constraints.constraint([oSpineFk.lJnts[i + 1], oCtrl.sPasser], sType = 'parent', bMaintainOffset = True) ## add ctrl shape sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName controls.addCtrlShape(oSpineIk.lCtrls + oSpineFk.lCtrls + oPelvisFk.lCtrls, sCtrlShape, bVis = False) cmds.addAttr(sCtrlShape, ln = 'ikCtrlVis', at = 'long', min = 0, max = 1) cmds.setAttr('%s.ikCtrlVis' %sCtrlShape, channelBox = True) attributes.connectAttrs(['%s.ikCtrlVis' %sCtrlShape], ['%s.v' %oSpineIk.sGrpCtrl], bForce = True) ## write rig info sModuleNodes = '%s,%s,%s' %(oSpineFk.sModuleNode, oPelvisFk.sModuleNode, oSpineIk.sModuleNode) sString_lJnts = self._convertListToString(self._lJnts) sString_lCtrls = self._convertListToString(oSpineFk.lCtrls + oPelvisFk.lCtrls + oSpineIk.lCtrls) lRigInfo = ['spineRig', self._sConnectInJnt, self._sConnectInCtrl, self._sConnectOutJnt, self._sConnectOutCtrl, self._sConnectOutRootCtrl,sString_lJnts, sString_lCtrls, sGrpCtrl, sModuleNodes, sGrp] lAttrs = ['sModuleType', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'sConnectOutRootCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'lModuleNodes', 'sModuleNode'] self._writeRigInfo(sGrp, lRigInfo, lAttrs) self._getRigInfo(sGrp)
def buildDeck(num=54, stack=0.015, holdValue=1.5): # identify if the hold value needs to decrease if (holdValue * num > 100): print('the hold value needs to decrease') intv = stack / num # interval between each cards # build card and attach to motion path for i in range(0, num): offsetGroup = cmds.group(em=True, name='car_offsetGrp_' + str(i)) if not advance: card = cmds.polyPlane(height=3.5, width=2.5, sw=1, sh=1, name='card_' + str(i)) elif advance: card = cmds.polyPlane(height=3.5, width=2.5, sw=1, sh=10, name='card_' + str(i)) cmds.parent(card[0], offsetGroup) cmds.pathAnimation(offsetGroup, curve='pokerPath', f=True, fm=True, name='mopathtest' + str(i)) cardPos = i * intv cmds.setAttr('mopathtest%s.uValue' % str(i), cardPos) cmds.addAttr(at='float', k=True, h=False, ln='pathValue') cmds.parent(offsetGroup, 'Deck') cards = cmds.ls('card*', transforms=True) for i, card in enumerate(cards): startPos = i * intv endPos = 1 - (stack - startPos) cmds.setDrivenKeyframe(card + '.pathValue', currentDriver='pokerPath.completion', dv=0, v=startPos) cmds.setDrivenKeyframe(card + '.pathValue', currentDriver='pokerPath.completion', dv=100, v=endPos) cmds.setDrivenKeyframe(card + '.pathValue', currentDriver='pokerPath.completion', dv=0 + (num - i) * holdValue, v=startPos) cmds.setDrivenKeyframe(card + '.pathValue', currentDriver='pokerPath.completion', dv=100 - i * holdValue, v=endPos) cmds.connectAttr(card + '.pathValue', 'mopathtest%s.uValue' % str(i), force=True) cmds.keyTangent(card, lock=False, itt='auto', ott='auto', index=[(1, 1), (2, 2)]) connectNode(cards) assignTexture(cards) if advance: addBlend() randomOffest(cards)
if len(selectList) >= 2: targetName = selectList[0] selectList.remove(targetName) locatorGroupName = cmds.group(empty=True, name='expantion_locator_grp#') maxExpantion = 100 newAttrName = 'expantion' if not cmds.objExists('%s.%s' % (targetName, newAttrName)): cmds.select(targetName) cmds.addAttr(longName=newAttrName, shortName='expa', attributeType='double', min=0, max=maxExpantion, defaultValue=maxExpantion, keyable=True) for objName in selectList: coords = cmds.getAttr('%s.translate' % (objName))[0] locatorName = cmds.spaceLocator(position=coords, name='%s_loc#' % (objName))[0] cmds.xform(locatorName, centerPivots=True) cmds.parent(locatorName, locatorGroupName) pointConstraintName = cmds.pointConstraint([targetName, locatorName], objName, name='%s_pointConstraint#' %
def traceArc(space='camera'): ''' The main function for creating the arc. ''' if space not in ('world','camera'): OpenMaya.MGlobal.displayWarning('Improper space argument.') return global ML_TRACE_ARC_PREVIOUS_SELECTION global ML_TRACE_ARC_PREVIOUS_SPACE globalScale = 1 if mc.optionVar(exists='ml_arcTracer_brushGlobalScale'): globalScale = mc.optionVar(query='ml_arcTracer_brushGlobalScale') #save for reset: origTime = mc.currentTime(query=True) #frame range frameRange = utl.frameRange() start = frameRange[0] end = frameRange[1] #get neccesary nodes objs = mc.ls(sl=True, type='transform') if not objs: OpenMaya.MGlobal.displayWarning('Select objects to trace') return ML_TRACE_ARC_PREVIOUS_SELECTION = objs ML_TRACE_ARC_PREVIOUS_SPACE = space cam = None nearClipPlane = None shortCam = '' if space=='camera': cam = utl.getCurrentCamera() #the arc will be placed just past the clip plane distance, but no closer than 1 unit. nearClipPlane = max(mc.getAttr(cam+'.nearClipPlane'),1) shortCam = mc.ls(cam, shortNames=True)[0] topGroup = 'ml_arcGroup' worldGrp = 'ml_arcWorldGrp' localGrp = 'ml_localGrp_'+shortCam #create nodes if not mc.objExists(topGroup): topGroup = mc.group(empty=True, name=topGroup) parentGrp = topGroup if space=='world' and not mc.objExists(worldGrp): worldGrp = mc.group(empty=True, name=worldGrp) mc.setAttr(worldGrp+'.overrideEnabled',1) mc.setAttr(worldGrp+'.overrideDisplayType',2) mc.parent(worldGrp, topGroup) parentGrp = mc.ls(worldGrp)[0] if space == 'camera': camConnections = mc.listConnections(cam+'.message', plugs=True, source=False, destination=True) if camConnections: for cc in camConnections: if '.ml_parentCam' in cc: localGrp = mc.ls(cc, o=True)[0] if not mc.objExists(localGrp): localGrp = mc.group(empty=True, name=localGrp) mc.parentConstraint(cam, localGrp) mc.setAttr(localGrp+'.overrideEnabled',1) mc.setAttr(localGrp+'.overrideDisplayType',2) mc.parent(localGrp, topGroup) mc.addAttr(localGrp, at='message', longName='ml_parentCam') mc.connectAttr(cam+'.message', localGrp+'.ml_parentCam') parentGrp = mc.ls(localGrp)[0] #group per object: group = [] for i,obj in enumerate(objs): sn = mc.ls(obj,shortNames=True)[0] name = sn.replace(':','_') groupName = 'ml_{}_arcGrp'.format(name) if mc.objExists(groupName): mc.delete(groupName) group.append(mc.group(empty=True, name=groupName)) group[i] = mc.parent(group[i],parentGrp)[0] mc.setAttr(group[i]+'.translate', 0,0,0) mc.setAttr(group[i]+'.rotate', 0,0,0) with utl.UndoChunk(): #determine the method to run. Test fast against accurate. #If fast is the same, continue with fast method. #Otherwise revert to accurate method. mc.currentTime(start) fastPoints = arcDataFast([objs[0]], parentGrp, start+1, start+1, space, nearClipPlane, cam) accuratePoints = arcDataAccurate([objs[0]], parentGrp, start+1, start+1, space, nearClipPlane, cam) points = None #if they're equivalent, continue with fast: if [int(x*1000000) for x in fastPoints[0][0]] == [int(x*1000000) for x in accuratePoints[0][0]]: points = arcDataFast([objs[0]], parentGrp, start, end, space, nearClipPlane, cam) else: points = arcDataAccurate([objs[0]], parentGrp, start, end, space, nearClipPlane, cam) #create the curves and do paint effects mc.ResetTemplateBrush() brush = mc.getDefaultBrush() mc.setAttr(brush+'.screenspaceWidth',1) mc.setAttr(brush+'.distanceScaling',0) mc.setAttr(brush+'.brushWidth',0.005) for i,obj in enumerate(objs): #setup brush for path globalScale mc.setAttr(brush+'.globalScale', globalScale) mc.setAttr(brush+'.screenspaceWidth',1) mc.setAttr(brush+'.distanceScaling',0) mc.setAttr(brush+'.brushWidth',0.003) #color for c in ('R','G','B'): color = random.uniform(0.3,0.7) mc.setAttr(brush+'.color1'+c,color) baseCurve = mc.curve(d=3,p=points[i]) #fitBspline makes a curve that goes THROUGH the points, a more accurate path curve = mc.fitBspline(baseCurve, constructionHistory=False, tolerance=0.001, name='ml_arcTracer_curve_#') mc.delete(baseCurve) #paint fx mc.AttachBrushToCurves(curve) stroke = mc.ls(sl=True)[0] mc.rename(mc.listConnections(stroke+'.brush', destination=False)[0], 'ml_arcTracer_brush_#') stroke = mc.parent(stroke,group[i])[0] mc.setAttr(stroke+'.overrideEnabled',1) mc.setAttr(stroke+'.overrideDisplayType',2) mc.setAttr(stroke+'.displayPercent',92) mc.setAttr(stroke+'.sampleDensity',0.5) mc.setAttr(stroke+'.inheritsTransform',0) mc.setAttr(stroke+'.translate',0,0,0) mc.setAttr(stroke+'.rotate',0,0,0) curve = mc.parent(curve,group[i])[0] mc.setAttr(curve+'.translate',0,0,0) mc.setAttr(curve+'.rotate',0,0,0) mc.hide(curve) #setup brush for tics if space=='camera': mc.setAttr(brush+'.brushWidth',0.008) if space=='world': mc.setAttr(brush+'.brushWidth',0.005) mc.setAttr(brush+'.color1G',0) mc.setAttr(brush+'.color1B',0) for t in range(len(points[i])): frameCurve = None if space=='camera': vec = utl.Vector(points[i][t][0],points[i][t][1],points[i][t][2]) vec*=0.98 frameCurve = mc.curve(d=1,p=[points[i][t],vec[:]]) elif space=='world': frameCurve = mc.circle(constructionHistory=False, radius=0.0001, sections=4)[0] mc.setAttr(frameCurve+'.translate', points[i][t][0], points[i][t][1], points[i][t][2]) constraint = mc.tangentConstraint(curve, frameCurve, aimVector=(0,0,1), worldUpType='scene') #mc.delete(constraint) #check for keyframe colorAttribute='color1G' if mc.keyframe(obj, time=((t+start-0.5),(t+start+0.5)), query=True): mc.setAttr(brush+'.color1R',1) else: mc.setAttr(brush+'.color1R',0) mc.AttachBrushToCurves(curve) stroke = mc.ls(sl=True)[0] thisBrush = mc.listConnections(stroke+'.brush', destination=False)[0] thisBrush = mc.rename(thisBrush, 'ml_arcTracer_brush_#') #setup keyframes for frame highlighting mc.setKeyframe(thisBrush, attribute='color1G', value=0, time=(start+t-1, start+t+1)) mc.setKeyframe(thisBrush, attribute='color1G', value=1, time=(start+t,)) stroke = mc.parent(stroke,group[i])[0] mc.hide(frameCurve) mc.setAttr(stroke+'.displayPercent',92) mc.setAttr(stroke+'.sampleDensity',0.5) frameCurve = mc.parent(frameCurve,group[i])[0] if space=='camera': mc.setAttr(stroke+'.inheritsTransform',0) mc.setAttr(stroke+'.pressureScale[1].pressureScale_Position', 1) mc.setAttr(stroke+'.pressureScale[1].pressureScale_FloatValue', 0) mc.setAttr(stroke+'.translate',0,0,0) mc.setAttr(stroke+'.rotate',0,0,0) mc.setAttr(frameCurve+'.translate',0,0,0) mc.setAttr(frameCurve+'.rotate',0,0,0) mc.currentTime(origTime, edit=True) panel = mc.getPanel(withFocus=True) try: mc.modelEditor(panel, edit=True, strokes=True) except: pass mc.select(objs,replace=True) mc.refresh()
def globalGammaCtrl(self,gammaVaule): gg = cmds.createNode('transform',n='globalGammaCtrl' ) cmds.addAttr(gg,ln='gamma',at='double',dv=gammaVaule) cmds.setAttr(gg+'.gamma',e=1,keyable=1)
def main(templateFile=None, controlShapes=None, fbx=False, scale=1, radius=1): template(filepath=templateFile, scale=scale) root.main(name="assembly", fbx=fbx, radius=radius, body=False, pelvis=False) mc.addAttr("assembly", ln="placers", at="bool", k=True) mc.addAttr("assembly", ln="wheels", at="bool", dv=True, k=True) mc.addAttr("assembly", ln="terrain", at="bool", dv=True, k=True) mc.addAttr("assembly", ln="editTerrain", at="bool", k=True) mc.addAttr("assembly", ln="terrainDetection", at="bool", dv=True, k=True) t = terrain.main(parent="world_ctrl", scale=scale * 10) wheels = [] jnts = mc.ls(typ="joint") or [] for jnt in jnts: if jnt.startswith("wheel"): grp, ctrl, ctrl2, _wheel = wheel.main(name=jnt.replace("_tmp", ""), terrain=t, radius=radius) mc.delete(mc.parentConstraint(jnt, grp, st="y")) ty = mc.xform(jnt, q=True, ws=True, rp=True)[1] mc.setAttr(ctrl2 + ".size", ty) wheels.append(grp) grp, ctrl = chassis.main(wheels=wheels, parent="world_ctrl", radius=radius) mc.parent(wheels, grp) mc.parent(grp, "cog_ctrl") mc.connectAttr("assembly.joints", ctrl + ".joints") mc.setAttr(ctrl + ".joints", k=False) mc.connectAttr("assembly.editJoints", ctrl + ".editJoints") mc.setAttr(ctrl + ".editJoints", k=False) mc.connectAttr("assembly.controls", ctrl + ".controls") mc.connectAttr("assembly.controls", "chassis_ctrlShape.v") mc.setAttr(ctrl + ".controls", k=False) mc.connectAttr("assembly.placers", ctrl + ".placers") mc.setAttr(ctrl + ".placers", k=False) mc.connectAttr("assembly.wheels", ctrl + ".wheels") mc.setAttr(ctrl + ".wheels", k=False) mc.connectAttr("assembly.terrain", t + ".v") mc.setAttr(ctrl + ".terrain", k=False) r = mc.createNode("reverse", ss=True) mc.connectAttr("assembly.editTerrain", r + ".inputX") mc.connectAttr(r + ".outputX", t + ".template") mc.setAttr(ctrl + ".editTerrain", k=False) mc.connectAttr("assembly.terrainDetection", ctrl + ".terrainDetection") mc.setAttr(ctrl + ".terrainDetection", k=False) if fbx: mc.createNode("joint", n="root_fbx", p="skeleton_fbx") mc.setAttr("root_fbx.radius", radius * 0.25) c = mc.pointConstraint("cog_ctrl", "root_fbx", sk=["y"])[0] mc.parent(c, "constraints_fbx") c = mc.orientConstraint("cog_ctrl", "root_fbx", sk=["x", "z"])[0] mc.parent(c, "constraints_fbx") c = mc.scaleConstraint("cog_ctrl", "root_fbx")[0] mc.parent(c, "constraints_fbx") mc.createNode("joint", n="chassis_fbx", p="root_fbx") mc.setAttr("chassis_fbx.radius", radius * 0.25) c = mc.parentConstraint("chassis_jnt", "chassis_fbx")[0] mc.parent(c, "constraints_fbx") c = mc.scaleConstraint("chassis_jnt", "chassis_fbx")[0] mc.parent(c, "constraints_fbx") for n in wheels: n = n.replace("_grp", "") mc.createNode("joint", n=n + "_fbx", p="chassis_fbx") mc.setAttr(n + "_fbx.radius", radius * 0.25) c = mc.parentConstraint(n + "_jnt", n + "_fbx")[0] mc.parent(c, "constraints_fbx") c = mc.scaleConstraint(n + "_jnt", n + "_fbx")[0] mc.parent(c, "constraints_fbx") if controlShapes: if os.path.isfile(THIS_DIR + "/" + controlShapes): common.loadControlShapes(THIS_DIR + "/" + controlShapes) elif os.path.isfile(controlShapes): common.loadControlShapes(controlShapes) mc.delete("template") mc.select(cl=True) mc.dgdirty(a=True)
def BT_AddPose(set=None, poseName='', index=None): prefixedPoseName = 'BT_' + poseName if not set: return False if not cmds.attributeQuery('Blend_Node', ex=True, n=set): return False if BT_IsSetupConnected(set=set): cmds.warning('Disconnect setup first!') return False blendNode = cmds.getAttr(set + '.Blend_Node') if not cmds.objExists(blendNode) or not cmds.objExists(set): return False if cmds.attributeQuery(prefixedPoseName, ex=True, n=set): return False transforms = cmds.listConnections(set + '.dagSetMembers') numTransforms = len(transforms) poseIndex = cmds.getAttr(blendNode + '.transforms[0].poses', size=True) if index is not None: poseIndex = index if index is None: cmds.addAttr(set, ln=prefixedPoseName, nn=poseName, k=True, min=0, max=1.0, at='double') # print ('Num poses = ' +str(numPoses)) for i in range(0, numTransforms): #get the base matrix baseScale = cmds.getAttr(blendNode + '.transforms[' + str(i) + '].baseScale')[0] baseMatrix = cmds.getAttr(blendNode + '.transforms[' + str(i) + '].baseMatrix') #store the scale and set it transformScale = cmds.getAttr(transforms[i] + '.scale')[0] #set the scale back to 1.0 cmds.setAttr(transforms[i] + '.scale', 1.0, 1.0, 1.0, type='double3') transformMatrix = cmds.xform(transforms[i], q=True, m=True) poseMatrix = [x - y for x, y in zip(transformMatrix, baseMatrix)] poseScale = [x - y for x, y in zip(transformScale, baseScale)] #set the scale back to what the user had it at cmds.setAttr(transforms[i] + '.scale', transformScale[0], transformScale[1], transformScale[2], type='double3') cmds.setAttr(blendNode + '.transforms[' + str(i) + '].poses[' + str(poseIndex) + '].matrix', poseMatrix, type='matrix') BT_Double3ValuesToNode(values=poseScale, node=blendNode, attr='transforms[' + str(i) + '].poses[' + str(poseIndex) + '].scale') if index is None: cmds.connectAttr( set + '.' + prefixedPoseName, blendNode + '.transforms[' + str(i) + '].poses[' + str(poseIndex) + '].weight') return True
def combineSingleAttrConnections(targetAttr, inputAttr1='', inputAttr2='', inputAttr1Value=None, inputAttr2Value=None, combineMode='add', enableAttributeOverride=False, blendAttr=''): """ Connect the combined result of 2 input attributes/values to a target attribute. @param targetAttr: Target attribute to receive the combined values result @type targetAttr: str @param inputAttr1: First attribute to be used to obtain the combined result @type inputAttr1: str @param inputAttr2: Second attribute to be used to obtain the combined result. If left as default (''), the existing input connection to targetAttr will be used. @type inputAttr2: str @param inputAttr1Value: Set the value of the first input @type inputAttr1Value: float @param inputAttr2Value: Set the value of the second input @type inputAttr2Value: float @param combineMode: How to combine the 2 input attribute values. Accepted inputs are "add", "mult" and "blend". @type combineMode: str @param enableAttributeOverride: If you specify both a source attribute and value for an input, this will attempt to set the source attribute to the input value. @type enableAttributeOverride: str @param blendAttr: Source attribute that will drive the attribute blend amount. If left as default (''), no connection will be made to the "blendNode.attributeBlender" attribute. @type blendAttr: str """ # Check existing connections existingConn = cmds.listConnections(targetAttr, s=True, d=False, p=True) # Check target attributes if not cmds.objExists(targetAttr): raise Exception('Target attribute ' + targetAttr + ' does not exist!') # Check inputs if (not inputAttr1) and (inputAttr1Value == None): raise Exception('No input attribute or value specified for input1!') if (not inputAttr2) and (inputAttr2Value == None): raise Exception('No input attribute or value specified for input2!') # Check input attributes if inputAttr1 and not cmds.objExists(inputAttr1): raise Exception('Input attribute 1 ' + inputAttr1 + ' does not exist!') if inputAttr2 and not cmds.objExists(inputAttr2): raise Exception('Input attribute 2 ' + inputAttr2 + ' does not exist!') # Get target node name if not targetAttr.count('.'): raise Exception(targetAttr + ' is not a valid attribute!') targetNode = targetAttr.split('.')[0] # Combine inputs combineNode = '' combineAttr1 = 'input1' combineAttr2 = 'input2' if combineMode == 'add': combineNode = self.nameUtil.appendName( targetNode, self.nameUtil.node['addDoubleLinear'], stripNameSuffix=True) combineNode = cmds.createNode('addDoubleLinear', n=combineNode) if combineMode == 'mult': combineNode = self.nameUtil.appendName( targetNode, self.nameUtil.node['multDoubleLinear'], stripNameSuffix=True) combineNode = cmds.createNode('multDoubleLinear', n=combineNode) if combineMode == 'blend': combineNode = self.nameUtil.appendName( targetNode, self.nameUtil.node['blendTwoAttr'], stripNameSuffix=True) combineNode = cmds.createNode('blendTwoAttr', n=combineNode) combineAttr1 = 'input[0]' combineAttr2 = 'input[1]' # Set Input 1 if inputAttr1: cmds.connectAttr(inputAttr1, combineNode + '.' + combineAttr1, f=True) if enableAttributeOverride and cmds.getAttr(inputAttr1, se=True): cmds.setAttr(inputAttr1, inputAttr1Value) else: cmds.setAttr(combineNode + '.' + combineAttr1, inputAttr1Value) # Set Input 2 if inputAttr2: cmds.connectAttr(inputAttr2, combineNode + '.' + combineAttr2, f=True) if enableAttributeOverride and cmds.getAttr(inputAttr2, se=True): cmds.setAttr(inputAttr2, inputAttr2Value) else: cmds.setAttr(combineNode + '.' + combineAttr2, inputAttr2Value) # Connect to target attribute cmds.connectAttr(combineNode + '.output', targetAttr, f=True) # Connect blend attribute if combineMode == 'blend' and blendAttr: # Check blend attribute if not cmds.objExists(blendAttr): if not blendAttr.count('.'): raise Exception(targetAttr + ' is not a valid object.attribute name!') blendAttrName = blendAttr.split('.') if len(blendAttrName) != 2: raise Exception(targetAttr + ' is not a valid object.attribute name!') if not cmds.objExists(blendAttrName[0]): raise Exception('Object ' + blendAttrName[0] + ' does not exist!') cmds.addAttr(blendAttrName[0], ln=blendAttrName[1], at='float', min=0, max=1, dv=0) cmds.setAttr(blendAttr, k=True) cmds.connectAttr(blendAttr, blendNode + '.attributesBlender', f=True) # Return result return combineNode
def createCtrl(cls, crv, jntLs): fkOpt = cmds.checkBoxGrp(cls.uiWdgDic['optChkBoxGrp'], q=True, v1=True) ctrlLs = [] # Create all control allCtrl = cmds.curve(n=crv + '_all_ctrl', d=3, p=[[0, 0, -2.995565], [0.789683, 0, -2.990087], [2.37399, 0, -2.329641], [3.317845, 0, 0.0217106], [2.335431, 0, 2.360484], [-0.0144869, 0, 3.320129], [-2.355941, 0, 2.340014], [-3.317908, 0, -0.00724357], [-2.353569, 0, -2.350269], [-0.76356, 0, -2.996864], [0, 0, -2.995565]], k=(0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 8.0, 8.0)) ctrlLs.append(allCtrl) ctrlGrpLs = cls.ctrlGrp(allCtrl) cmds.delete(cmds.parentConstraint(jntLs[0], ctrlGrpLs[0], mo=False)) cmds.addAttr(allCtrl, ln='bindJointsVis', nn='Bind Joints Vis', keyable=True, at='bool') cmds.setAttr('%s.visibility' % allCtrl, lock=True, keyable=False, channelBox=False) # Create each joint control for jnt in jntLs: # Create cube shape control ctrl = cmds.curve( n=jnt.rsplit('_rbBnd_jnt')[0] + '_ctrl', d=1, p=[(-1, 1, 1), (1, 1, 1), (1, 1, -1), (-1, 1, -1), (-1, 1, 1), (-1, -1, 1), (-1, -1, -1), (1, -1, -1), (1, -1, 1), (-1, -1, 1), (1, -1, 1), (1, 1, 1), (1, 1, -1), (1, -1, -1), (-1, -1, -1), (-1, 1, -1)], k=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]) ctrlLs.append(ctrl) # Lock and hide unused attributes of control. unUsedAttr = ['scaleX', 'scaleY', 'scaleZ', 'visibility'] for attr in unUsedAttr: cmds.setAttr("%s.%s" % (ctrl, attr), lock=True, keyable=False, channelBox=False) # Control group hierarchy ctrlGrpLs = cls.ctrlGrp(ctrl) cmds.parent(ctrl, ctrlGrpLs[2]) # Match control to the joint cmds.delete(cmds.parentConstraint(jnt, ctrlGrpLs[0], mo=False)) # Constraint part cmds.parentConstraint(ctrl, jnt, mo=False) cmds.scaleConstraint(ctrl, jnt, mo=False) if fkOpt: cmds.orientConstraint(ctrl, ctrlGrpLs[3], mo=False) # Parent to the parent child rotation pivot group matchObj = re.match(r'(.+)_(\d+)_.+', jnt) crvName = matchObj.group(1) jntNum = int(matchObj.group(2)) if jntNum == 0: cmds.parent(ctrlGrpLs[3], '%s_all_ctrl' % crvName) else: parentJntNum = jntNum - 1 cmds.parent(ctrlGrpLs[0], ctrlGrpLs[3], '%s_%d_ctrl_chldRoPivot' % (crvName, parentJntNum)) cmds.parent(ctrlLs[1] + '_zero', allCtrl) return ctrlLs
def create(spaceNode, spaceSwitch=None, parent=None, mode='parent', master_node='Main', verbose=False): ''' other modes: 'orient', 'point' nodes in the network: spaceGrp: node to group the space targets (usually parented to the noXform_grp) 'Lf_arm_ikh_zeroSpaces' spaceSwitch: node used to mamage switch (usually a control) 'Lf_arm_ikh_ctrl' spaceNode: node that gets constrained to the various space targets (usually a parent of the control node) 'Lf_arm_ikh_zero' spaceConstraint: constraint node used to switch spaces 'Lf_arm_ikh_zero_parentConstraint1' ''' if verbose == True: print('creating space node for %s' % spaceNode) if not spaceSwitch: spaceSwitch = spaceNode if not cmds.objExists(spaceNode + '.spaceGrp'): # Space Group grp = cmds.createNode('transform', n=spaceNode + 'Spaces', parent=parent) cmds.setAttr(grp + '.inheritsTransform', False) decomposeMatrix = cmds.createNode('decomposeMatrix') cmds.connectAttr(spaceNode + '.parentMatrix', decomposeMatrix + '.inputMatrix') cmds.connectAttr(decomposeMatrix + '.outputTranslate', grp + '.translate') cmds.connectAttr(decomposeMatrix + '.outputRotate', grp + '.rotate') cmds.connectAttr(decomposeMatrix + '.outputScale', grp + '.scale') # Initial Space = MasterOffset cmds.addAttr(spaceSwitch, ln=SPACEATTR, attributeType='enum', enumName='master', keyable=True) masterSpace = cmds.createNode('transform', name=grp + '_master', parent=grp) matchPose(spaceNode, masterSpace) if not cmds.objExists(master_node): cmds.createNode("transform", name=master_node) cmds.parentConstraint(master_node, masterSpace, mo=True) #cmds.parentConstraint("Main", masterSpace, mo=True) lockAndHide(['t', 'r', 's', 'v'], masterSpace) # Space Constraint if mode == 'point': constraint = cmds.pointConstraint(masterSpace, spaceNode, mo=True)[0] if mode == 'orient': constraint = cmds.orientConstraint(masterSpace, spaceNode, mo=True)[0] else: constraint = cmds.parentConstraint(masterSpace, spaceNode, mo=True)[0] # Message Attrs (for tracing network) cmds.addAttr(spaceNode, ln='spaceGrp', at='message', keyable=True) cmds.connectAttr(grp + '.message', spaceNode + '.spaceGrp') cmds.addAttr(spaceSwitch, ln='spaceNode', at='message', keyable=True) cmds.connectAttr(spaceNode + '.message', spaceSwitch + '.spaceNode') cmds.addAttr(spaceNode, ln='spaceConstraint', at='message', keyable=True) cmds.connectAttr(constraint + '.message', spaceNode + '.spaceConstraint') cmds.addAttr(spaceNode, ln='spaceSwitch', at='message', keyable=True) cmds.connectAttr(spaceSwitch + '.' + SPACEATTR, spaceNode + '.spaceSwitch') return (spaceNode) else: print 'spaces.create: ' + spaceNode + 'already exists. Use spaces.add' return None
def _create_twist_decomposition_network(driver, twist_axis): """Create the twist decomposition network for driver. :param driver: Driver transform :param twist_axis: Local twist axis on driver """ # Connect message attributes to the decomposed twist nodes so we can reuse them # if the network is driving multiple nodes if not cmds.objExists("{}.{}".format(driver, TWIST_OUTPUT)): cmds.addAttr(driver, ln=TWIST_OUTPUT, at="message") if not cmds.objExists("{}.{}".format(driver, INVERTED_TWIST_OUTPUT)): cmds.addAttr(driver, ln=INVERTED_TWIST_OUTPUT, at="message") # Store the current local matrix of driver to be used as a frame of reference if not cmds.objExists("{}.{}".format(driver, REST_MATRIX)): cmds.addAttr(driver, ln=REST_MATRIX, at="matrix") rest_matrix = cmds.getAttr("{}.m".format(driver)) cmds.setAttr("{}.restMatrix".format(driver), rest_matrix, type="matrix") # Get the local offset matrix which is the matrix from the world rest xform to # the current world xform world_rest_matrix = cmds.createNode( "multMatrix", name="{}_world_rest_matrix".format(driver)) for i, attr in enumerate(["parentMatrix[0]", REST_MATRIX]): cmds.connectAttr("{}.{}".format(driver, attr), "{}.matrixIn[{}]".format(world_rest_matrix, i)) world_rest_inverse = cmds.createNode( "inverseMatrix", name="{}_world_rest_inverse".format(driver)) cmds.connectAttr( "{}.matrixSum".format(world_rest_matrix), "{}.inputMatrix".format(world_rest_inverse), ) local_offset_matrix = cmds.createNode( "multMatrix", name="{}_local_offset_matrix".format(driver)) cmds.connectAttr("{}.worldMatrix[0]".format(driver), "{}.matrixIn[0]".format(local_offset_matrix)) cmds.connectAttr( "{}.outputMatrix".format(world_rest_inverse), "{}.matrixIn[1]".format(local_offset_matrix), ) # Transform the twist axis by the local offset matrix if twist_axis is None: twist_axis = _get_local_twist_axis(driver) local_twist_axis = cmds.createNode("vectorProduct", name="{}_twist_axis".format(driver)) cmds.setAttr("{}.operation".format(local_twist_axis), 3) # Vector Matrix Product cmds.setAttr("{}.input1".format(local_twist_axis), *twist_axis) cmds.connectAttr("{}.matrixSum".format(local_offset_matrix), "{}.matrix".format(local_twist_axis)) cmds.setAttr("{}.normalizeOutput".format(local_twist_axis), True) # Get the angle between the rest and transformed twist axis to get the swing # rotation swing_euler = cmds.createNode("angleBetween", name="{}_swing_euler".format(driver)) cmds.connectAttr("{}.input1".format(local_twist_axis), "{}.vector1".format(swing_euler)) cmds.connectAttr("{}.output".format(local_twist_axis), "{}.vector2".format(swing_euler)) # Convert the swing euler rotation to quaternion swing = cmds.createNode("eulerToQuat", name="{}_swing".format(driver)) cmds.connectAttr("{}.euler".format(swing_euler), "{}.inputRotate".format(swing)) # Remove the inverse swing from the local offset to be left with the twist swing_inverse = cmds.createNode("quatInvert", name="{}_swing_inverse".format(driver)) cmds.connectAttr("{}.outputQuat".format(swing), "{}.inputQuat".format(swing_inverse)) local_rotation = cmds.createNode("decomposeMatrix", name="{}_local_rotation".format(driver)) cmds.connectAttr( "{}.matrixSum".format(local_offset_matrix), "{}.inputMatrix".format(local_rotation), ) twist = cmds.createNode("quatProd", name="{}_twist".format(driver)) cmds.connectAttr("{}.outputQuat".format(local_rotation), "{}.input1Quat".format(twist)) cmds.connectAttr("{}.outputQuat".format(swing_inverse), "{}.input2Quat".format(twist)) cmds.connectAttr("{}.message".format(twist), "{}.{}".format(driver, TWIST_OUTPUT)) twist_inverse = cmds.createNode("quatInvert", name="{}_twist_inverse".format(driver)) cmds.connectAttr("{}.outputQuat".format(twist), "{}.inputQuat".format(twist_inverse)) cmds.connectAttr( "{}.message".format(twist_inverse), "{}.{}".format(driver, INVERTED_TWIST_OUTPUT), )
def dpCreateRivet(self, geoToAttach, uvSetName, itemList, attachTranslate, attachRotate, addFatherGrp, addInvert, invT, invR, rivetGrpName='Rivet_Grp', askComponent=False, *args): """ Create the Rivet setup. """ # declaring variables self.shapeToAttachList = None self.shapeToAttach = None self.cpNode = None self.tempNoce = None attrList = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'] self.rivetList, togetherList = [], [] isComponent = None # integrate to dpAutoRigSystem: self.masterGrp = None self.masterCtrl = None self.scalableGrp = None allList = cmds.ls(selection=False, type="transform") if allList: for node in allList: if cmds.objExists(node+"."+MASTER_GRP) and cmds.getAttr(node+"."+MASTER_GRP) == 1: self.masterGrp = node if self.masterGrp: masterCtrlList = cmds.listConnections(self.masterGrp+".masterCtrl") scalableGrpList = cmds.listConnections(self.masterGrp+".scalableGrp") if masterCtrlList: self.masterCtrl = masterCtrlList[0] if scalableGrpList: self.scalableGrp = scalableGrpList[0] # create Rivet_Grp in order to organize hierarchy: createdRivetGrp = False self.rivetGrp = rivetGrpName if not cmds.objExists(rivetGrpName): createdRivetGrp = True self.rivetGrp = cmds.group(name=rivetGrpName, empty=True) for attr in attrList: cmds.setAttr(self.rivetGrp+"."+attr, lock=True, keyable=False, channelBox=False) cmds.addAttr(self.rivetGrp, longName="dpRivetGrp", attributeType='bool') cmds.setAttr(self.rivetGrp+".dpRivetGrp", 1) if self.scalableGrp: cmds.parent(self.rivetGrp, self.scalableGrp) # get shape to attach: if cmds.objExists(geoToAttach): self.shapeToAttachList = cmds.ls(geoToAttach, dag=True, shapes=True) if self.shapeToAttachList: self.shapeToAttach = self.shapeToAttachList[0] # get shape type: self.shapeType = cmds.objectType(self.shapeToAttach) # verify if there are vertices, cv's or lattice points in our itemList: if itemList: asked = False for i, item in enumerate(itemList): if ".vtx" in item or ".cv" in item or ".pt" in item: if askComponent: if not asked: isComponent = cmds.confirmDialog(title="dpRivet on Components", message="How do you want attach vertices, cv's or lattice points?", button=("Individually", "Together", "Ignore"), defaultButton="Individually", dismissString="Ignore", cancelButton="Ignore") asked = True if isComponent == "Individually": cls = cmds.cluster(item, name=item[:item.rfind(".")]+"_"+str(i)+"_Cls")[0]+"Handle" clsToRivet = cmds.parent(cls, self.rivetGrp)[0] self.rivetList.append(clsToRivet) elif isComponent == "Together": togetherList.append(item) elif isComponent == "Ignore": itemList.remove(item) elif isComponent == "Ignore": itemList.remove(item) elif isComponent == "Together": togetherList.append(item) else: #Individually cls = cmds.cluster(item, name=item[:item.rfind(".")]+"_"+str(i)+"_Cls")[0]+"Handle" clsToRivet = cmds.parent(cls, self.rivetGrp)[0] self.rivetList.append(clsToRivet) else: #Individually cls = cmds.cluster(item, name=item[:item.rfind(".")]+"_"+str(i)+"_Cls")[0]+"Handle" clsToRivet = cmds.parent(cls, self.rivetGrp)[0] self.rivetList.append(clsToRivet) elif cmds.objExists(item): self.rivetList.append(item) else: mel.eval("error \"Select and add at least one item to be attached as a Rivet, please.\";") if isComponent == "Together": cls = cmds.cluster(togetherList, name="dpRivet_Cls")[0]+"Handle" clsToRivet = cmds.parent(cls, self.rivetGrp)[0] self.rivetList.append(clsToRivet) # check about locked or animated attributes on items: if not addFatherGrp: cancelProcess = False for rivet in self.rivetList: # locked: if cmds.listAttr(rivet, locked=True): cancelProcess = True break # animated: for attr in attrList: if cmds.listConnections(rivet+"."+attr, source=True, destination=False): cancelProcess = True break if cancelProcess: if createdRivetGrp: cmds.delete(self.rivetGrp) else: for rivet in self.rivetList: if not rivet in itemList: # clear created clusters: cmds.delete(rivet) mel.eval("error \"Canceled process: items to be Rivet can't be animated or have locked attributes, sorry.\";") return # workarount to avoid closestPoint node ignores transformations. # then we need to duplicate, unlock attributes and freezeTransformation: dupGeo = cmds.duplicate(geoToAttach, name=geoToAttach+"_dpRivet_TEMP_Geo")[0] # unlock attr: for attr in attrList: cmds.setAttr(dupGeo+"."+attr, lock=False) # parent to world: if cmds.listRelatives(dupGeo, allParents=True): cmds.parent(dupGeo, world=True) # freezeTransformation: cmds.makeIdentity(dupGeo, apply=True) dupShape = cmds.ls(dupGeo, dag=True, shapes=True)[0] # temporary transform node to store object's location: self.tempNode = cmds.createNode("transform", name=geoToAttach+"_dpRivet_TEMP_Transf", skipSelect=True) # working with mesh: if self.shapeType == "mesh": # working with uvSet: uvSetList = cmds.polyUVSet(dupShape, query=True, allUVSets=True) if len(uvSetList) > 1: if not uvSetList[0] == uvSetName: # change uvSet order because closestPointOnMesh uses the default uv set cmds.polyUVSet(dupShape, copy=True, uvSet=uvSetName, newUVSet=uvSetList[0]) # closest point on mesh node: self.cpNode = cmds.createNode("closestPointOnMesh", name=geoToAttach+"_dpRivet_TEMP_CP", skipSelect=True) cmds.connectAttr(dupShape+".outMesh", self.cpNode+".inMesh", force=True) # move tempNode to cpNode position: cmds.connectAttr(self.tempNode+".translate", self.cpNode+".inPosition", force=True) else: #nurbsSurface uRange = cmds.getAttr(dupShape+".minMaxRangeU")[0] vRange = cmds.getAttr(dupShape+".minMaxRangeV")[0] # closest point on mesh node: self.cpNode = cmds.createNode("closestPointOnSurface", name=geoToAttach+"_dpRivet_TEMP_CP", skipSelect=True) cmds.connectAttr(dupShape+".local", self.cpNode+".inputSurface", force=True) # working with follicles and attaches for rivet in self.rivetList: rivetPos = cmds.xform(rivet, query=True, worldSpace=True, rotatePivot=True) if addFatherGrp: rivet = cmds.group(rivet, name=rivet+"_Rivet_Grp") cmds.xform(rivet, worldSpace=True, rotatePivot=(rivetPos[0], rivetPos[1], rivetPos[2])) # move temp tranform to rivet location: cmds.xform(self.tempNode, worldSpace=True, translation=(rivetPos[0], rivetPos[1], rivetPos[2])) # get uv coords from closestPoint node fu = cmds.getAttr(self.cpNode+".u") fv = cmds.getAttr(self.cpNode+".v") if self.shapeType == "nurbsSurface": # normalize UVs: fu = abs((fu - uRange[0])/(uRange[1] - uRange[0])) fv = abs((fv - vRange[0])/(vRange[1] - vRange[0])) # create follicle: folTransf = cmds.createNode("transform", name=rivet+"_Fol", parent=self.rivetGrp, skipSelect=True) folShape = cmds.createNode("follicle", name=rivet+"_FolShape", parent=folTransf, skipSelect=True) # connect geometry shape and follicle: if self.shapeType == "mesh": cmds.connectAttr(self.shapeToAttach+".worldMesh[0]", folShape+".inputMesh", force=True) cmds.setAttr(folShape+".mapSetName", uvSetName, type="string") else: #nurbsSurface: cmds.connectAttr(self.shapeToAttach+".local", folShape+".inputSurface", force=True) cmds.connectAttr(self.shapeToAttach+".worldMatrix[0]", folShape+".inputWorldMatrix", force=True) cmds.connectAttr(folShape+".outRotate", folTransf+".rotate", force=True) cmds.connectAttr(folShape+".outTranslate", folTransf+".translate", force=True) # put follicle in the correct place: cmds.setAttr(folShape+".parameterU", fu) cmds.setAttr(folShape+".parameterV", fv) # attach follicle and rivet using constraint: if attachTranslate and attachRotate: cmds.parentConstraint(folTransf, rivet, maintainOffset=True, name=rivet+"_ParentConstraint") elif attachTranslate: cmds.parentConstraint(folTransf, rivet, maintainOffset=True, name=rivet+"_ParentConstraint" , skipRotate=("x", "y", "z")) elif attachRotate: cmds.parentConstraint(folTransf, rivet, maintainOffset=True, name=rivet+"_ParentConstraint" , skipTranslate=("x", "y", "z")) # try to integrate to dpAutoRigSystem in order to keep the Rig as scalable: if self.masterCtrl: cmds.scaleConstraint(self.masterCtrl, folTransf, maintainOffset=True, name=folTransf+"_ScaleConstraint") # check invert group (back) in order to avoide double transformations: if addInvert: for rivet in self.rivetList: self.dpInvertAttrTranformation(rivet, invT, invR) # clean-up temporary nodes: cmds.delete(dupGeo, self.cpNode, self.tempNode) else: mel.eval("error \"Load one geometry to attach Rivets on it, please.\";") cmds.select(clear=True)
def addCustomUDIMMeshAttributes(mesh_name): #Adding custom UDIM attribute to meshes in a group if not cmds.objExists('%s.udim' % mesh_name): cmds.addAttr(mesh_name, shortName='udim', longName='udim', at='short', defaultValue= 1002, keyable=True)
def createRbnCtrl(posGrpList=[], radius=1, side='', firstJnt='', secondJnt='', nurbsName=''): skinJntNameList = [] dtlCtrlNameList = [] dtlCtrlZgrpNameList = [] mainJntNameList = [] mainCtrlNameList = [] mainCtrlZgrpNameList = [] posMainJntList = [firstJnt, secondJnt] mainJntPosList = [] posMainJntDesList = ['_rbnStart', '_rbnMid', '_rbnEnd'] firstJntName = firstJnt.split('_')[0] skinGrpName = firstJntName + '_rbnSkin' + side + '_grp' # * create skinJnt dltCtrl for i in range(0, len(posGrpList)): # nameing ctrlName = posGrpList[i].split('_')[0] + '_rbnDtl' + side + '_ctrl' jntName = posGrpList[i].split('_')[0] + '_rbnDtl' + side + '_jnt' # add jnt to List skinJntNameList.append(jntName) # create ctrl mc.circle(nr=(0, 1, 0), c=(0, 0, 0), n=ctrlName) mc.setAttr(ctrlName + '.sx', radius) mc.setAttr(ctrlName + '.sz', radius) mc.delete(ctrlName, ch=True) # create jnt mc.select(cl=True) mc.joint(n=jntName, p=[0, 0, 0]) mc.select(cl=True) # make ctrl and jnt have the same pviot gn.parentConOffMainTain(jntName, posGrpList[i]) gn.parentConOffMainTain(ctrlName, posGrpList[i]) mc.makeIdentity(jntName, apply=True, t=1, r=1, s=1, n=2) # add dtlCtrl to list dtlCtrlNameList.append(ctrlName) # make zGrp dtlCtrlZgrpNameList.append(gn.zeroGroup(ctrlName, posGrpList[i])) # parentConstrain mc.parentConstraint(posGrpList[i], dtlCtrlZgrpNameList[i]) # parent jnt to ctrl mc.parentConstraint(ctrlName, jntName, mo=False) # create skinGrp mc.group(em=True, n=skinGrpName) # parent skinJnt into skinGrp mc.parent(skinJntNameList, skinGrpName) # * create mainCtrl # get ThridJnt world Position mc.select(cl=True) thirdJnt = mc.joint(n='thirdJnt', p=[0, 0, 0]) ampCon = mc.parentConstraint([firstJnt, secondJnt], thirdJnt) mc.delete(ampCon) # app posJnt to List at index 1 posMainJntList.insert(1, thirdJnt) # get jnt position from posJnt mainJntPosList = list(map(gn.getWorldPosition, posMainJntList)) # delete thirdJnr mc.delete(thirdJnt) for i in range(0, 3): mc.select(cl=True) jnt = mc.joint(n=firstJntName + posMainJntDesList[i] + side + '_jnt', p=[0, 0, 0]) ampCon = mc.parentConstraint(posGrpList[1], jnt, mo=False) mc.delete(ampCon) mc.setAttr(jnt + '.t', mainJntPosList[i][0], mainJntPosList[i][1], mainJntPosList[i][2]) # add each jnt to the List mainJntNameList.append(jnt) # nameing mainCtrl mainCtrlName = mainJntNameList[i].split( '_')[0] + posMainJntDesList[i] + side + '_ctrl' # create mainCtrl mainCtrlAmp = mc.curve(p=[(-1, 0, -1), (-1, 0, 1), (1, 0, 1), (1, 0, -1), (-1, 0, -1)], k=[0, 1, 2, 3, 4], d=1) mc.rename(mainCtrlAmp, mainCtrlName) mc.setAttr(mainCtrlName + '.sx', radius) mc.setAttr(mainCtrlName + '.sz', radius) # mark ctrl has same direction to jnt gn.parentConOffMainTain(mainCtrlName, jnt) # create zGrp and put into list mainCtrlZgrpNameList.append(gn.zeroGroup(mainCtrlName, mainCtrlName)) mainCtrlNameList.append(mainCtrlName) mc.parent(jnt, mainCtrlName) # create ctrlGrp ctrlGrpName = mc.group(em=True, n=firstJntName + '_rbnCtrl' + side + '_grp') # parentConstraint ctrlGrpName -> firstJnt mc.parentConstraint(firstJnt, ctrlGrpName) # pontConstraint endCtrl -> secondJnt mc.pointConstraint(secondJnt, mainCtrlZgrpNameList[-1], mo=True) # put all mainCtrl in to ctrlGrpName mc.parent(mainCtrlZgrpNameList, ctrlGrpName) dtlCtrlGrpName = mc.group(em=True, n=firstJntName + '_rbnDtlCtrl' + side + '_grp') # parentConstraint ctrlGrpName -> dtlCtrlGrpName and then delete parent mc.delete(mc.parentConstraint(ctrlGrpName, dtlCtrlGrpName)) # parent dtlCtrlGrpName -> ctrlGrpName mc.parent(dtlCtrlGrpName, ctrlGrpName) # parent dtlCtrlZgrpNameList -> dtlCtrlGrpName mc.parent(dtlCtrlZgrpNameList, dtlCtrlGrpName) # parentConstraint ctrlGrpName -> skinGrpName mc.parentConstraint(ctrlGrpName, skinGrpName, mo=True) mc.pointConstraint(mainJntNameList[0], mainJntNameList[-1], mainCtrlZgrpNameList[1]) # aim startJnt and ndJnt to midJnt if side == 'LFT': mc.aimConstraint(mainJntNameList[1], mainJntNameList[0], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=mainJntNameList[1]) mc.aimConstraint(mainJntNameList[1], mainJntNameList[2], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=mainJntNameList[1]) mc.aimConstraint(mainJntNameList[2], mainCtrlZgrpNameList[1], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=firstJnt) elif side == 'RGT': mc.aimConstraint(mainJntNameList[1], mainJntNameList[0], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=mainJntNameList[1]) mc.aimConstraint(mainJntNameList[1], mainJntNameList[2], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=mainJntNameList[1]) mc.aimConstraint(mainJntNameList[2], mainCtrlZgrpNameList[1], weight=1, aimVector=(0, 1, 0), upVector=(0, 0, 1), worldUpType='objectrotation', worldUpVector=(0, 0, 1), worldUpObject=secondJnt) # bindSkin mc.skinCluster(mainJntNameList[0], mainJntNameList[1], mainJntNameList[2], nurbsName) # setAttr skinGrp, startCtrl and endCtrl to be unseen mc.setAttr(skinGrpName + '.v', False) mc.setAttr(mainCtrlNameList[0] + '.v', False) mc.setAttr(mainCtrlNameList[2] + '.v', False) mc.setAttr(mainJntNameList[1] + '.v', False) # add attr dtlCtrl to mid ctrl mc.addAttr(mainCtrlNameList[1] + 'Shape', ln='detailCtrl', at='double', min=0, max=1, dv=0, k=True) # connecting Attr mc.connectAttr(mainCtrlNameList[1] + 'Shape.detailCtrl', dtlCtrlGrpName + '.v') # return dtlCtrlZgrpNameList ,mainCtrlZgrpNameList, skinJntNameList return { 'dtlCtrlNameList': dtlCtrlNameList, 'mainCtrlNameList': mainCtrlNameList, 'skinJntNameList': skinJntNameList }
def createPalmCtrls(self, jntPalmBase, leftRight, colourTU, jntPalm, isLeft, *args): # create the CTRL, then move it handOffsetCtrl = CRU.createCTRLs(jntPalmBase, 5, ornt=True, pnt=True, colour=colourTU, orientVal=(1, 0, 0)) handLength = mc.getAttr("{0}.ty".format(jntPalm[1])) mc.select(handOffsetCtrl[1] + ".cv[:]") moveX = -handLength / 2 mc.move(moveX, handLength * 0.5, 0, r=True, ls=True) # add the twist limits for the wrists: lowerTwistVal = "lowerArmTwist" upperTwistVal = "upperArmTwist" mc.addAttr(handOffsetCtrl[1], longName=lowerTwistVal, at="float", k=True, min=0, max=1, dv=1) mc.addAttr(handOffsetCtrl[1], longName=upperTwistVal, at="float", k=True, min=0, max=1, dv=1) # get the expression (this is a bit unique to me) then edit it armExprName = "expr" + leftRight + "armTwist" armExpr = mc.expression(armExprName, q=True, s=True) ctrlPalmName = "CTRL" + leftRight + "palm" armExpr = armExpr.replace("armEnd", "palm") armExpr = armExpr.replace("JNT" + leftRight + "palm", ctrlPalmName) editExpr = armExpr.splitlines() for i in range(len(editExpr)): if "lowerArm.rotate" in editExpr[i]: # if we're rotating the upper arm twists with the lower arm replaceTwistVal = upperTwistVal elif "palm.rotate" in editExpr[i]: # if we're rotating the lower arm twists with the palm replaceTwistVal = lowerTwistVal editExpr[i] = editExpr[i].replace( ";", " * {0}.{1};\n".format(ctrlPalmName, replaceTwistVal)) # print(editExpr[i]) armExprReplace = "".join(editExpr) # print(armExprReplace) mc.delete(armExprName) mc.expression(s=armExprReplace, n=armExprName) # change the rotation order toRotateChange = [handOffsetCtrl[1], jntPalmBase] CRU.changeRotateOrder(toRotateChange, "YZX") return handOffsetCtrl
def createMasterBodyCog(rig, master, body, cog, root, traj): """Creates top rig hierarchy """ master_ctl = None master_offset_ctl = None body_ctl = None piv_inv = None root_jnt = None if master: # Create buffer and scene_offset nodes master_GRP = cmds.createNode("transform", name=MASTER.replace(CTL, GRP)) scene_OFF = cmds.createNode("transform", name="sceneOffset_{}".format(GRP)) # Master and master_offset master_ctl = master.name() master_ctl_parent = cmds.listRelatives(master_ctl, parent=True) if master_ctl_parent: cmds.parent(master_GRP, master_ctl_parent) master_offset_ctl = "" if cmds.objExists(MASTER_OFFSET): master_offset_ctl = MASTER_OFFSET attrs_show(TRS, node=master_ctl) attrs_show(TRS, node=master_offset_ctl) cmds.parent(scene_OFF, master_GRP) cmds.parent(master_ctl, scene_OFF) # Try to parent master_grp under rig node try: cmds.parent(master_GRP, rig['rigGroup']) except: pass # Setup global scale on master and connect to master_offset cmds.addAttr(master_ctl, ln="globalScale", min=0.0001, dv=1) cmds.setAttr("{}.globalScale".format(master_ctl), edit=True, l=False, k=True) for attr in ['sx', 'sy', 'sz']: cmds.connectAttr("{}.globalScale".format(master_ctl), "{}.{}".format(master_offset_ctl, attr)) cmds.setAttr("{}.{}".format(master_offset_ctl, attr), lock=True) cmds.setAttr("{}.{}".format(master_ctl, attr), lock=True) # Set channels attrs_lock_hide(SV, node=master_ctl) attrs_lock_hide(SV, node=master_offset_ctl) # Meta types dragonfly.modules.add_metatype(master_ctl, dragonfly.meta_types.MTYPE_MASTER) dragonfly.modules.add_metatype(master_offset_ctl, dragonfly.meta_types.MTYPE_MASTER_OFFSET) dragonfly.modules.add_metatype(master_ctl, dragonfly.meta_types.MTYPE_CTL) dragonfly.modules.add_metatype(master_offset_ctl, dragonfly.meta_types.MTYPE_CTL) if body: # Create buffer body_BUF = cmds.createNode("transform", name=BODY.replace(CTL, BUF)) # Body control body_ctl = body.name() match_nodes(body_ctl, body_BUF) cmds.parent(body_ctl, body_BUF) if cmds.objExists(MASTER_OFFSET): cmds.parent(body_BUF, MASTER_OFFSET) else: cmds.parent(body_BUF, MASTER) piv_inv = add_movable_pivot(BODY.replace("_{}".format(CTL), ""), body_ctl) # Set channels attrs_lock_hide(SV, node=body_ctl) # Meta type dragonfly.modules.add_metatype(body_ctl, dragonfly.meta_types.MTYPE_BODY) if cog: # Create buffer cog_BUF = cmds.createNode("transform", name=COG.replace(CTL, BUF)) cog_ctl = cog.name() match_nodes(cog_ctl, cog_BUF) if body_ctl: cmds.parent(cog_BUF, BODY) cog_off = cmds.createNode("transform", name=COG.replace(CTL, OFF)) match_nodes(cog_ctl, cog_off) cmds.parent(cog_off, cog_BUF) cmds.parent(cog_ctl, cog_off) cmds.parentConstraint(piv_inv, cog_BUF, mo=True) else: cmds.parent(cog_ctl, cog_BUF) # Set channels attrs_lock_hide(SV, node=cog_ctl) # Meta type dragonfly.modules.add_metatype(cog_ctl, dragonfly.meta_types.MTYPE_COG) if root: root_jnt = root.name() attrs_show(TRSV, node=root_jnt) if master_offset_ctl: cmds.parentConstraint(master_offset_ctl, root_jnt) cmds.scaleConstraint(master_offset_ctl, root_jnt) try: skel_grp = rig['skeletonGroup'] if skel_grp: cmds.parent(root_jnt, skel_grp) except: pass # Meta type dragonfly.modules.add_metatype(root_jnt, dragonfly.meta_types.MTYPE_ROOT) if traj: if master_ctl and root_jnt: traj = trajectoryControl(masterControl=master_ctl, rootJoints=[root_jnt]) attrs_lock_hide(SV, node=traj) dragonfly.modules.add_metatype(traj, dragonfly.meta_types.MTYPE_TRAJECTORY)
def rbnSquash(midCtrl='', ctrlGrpName='', crvShape='', dtlCtrlList=[], skinJntNameList=[], side=''): squashRatio = [0.15, 0.5, 1.0, 0.5, 0.15] autoSquashName = midCtrl.split('_')[0] # globalCrv setup globalCrvName = autoSquashName + '_rbnGlobal' + side + '_crv' cifAutoGlobalNode = autoSquashName + '_rbnGlobal' + side + '_cif' cifAutoNode = midCtrl.split('_')[0] + '_rbn' + side + '_cif' mc.duplicate(crvShape, n=globalCrvName) mc.createNode('curveInfo', n=cifAutoGlobalNode) mc.createNode('curveInfo', n=cifAutoNode) mc.parent(globalCrvName, ctrlGrpName) mc.connectAttr(globalCrvName + 'Shape.worldSpace', cifAutoGlobalNode + '.inputCurve') mc.connectAttr(crvShape + 'Shape.worldSpace', cifAutoNode + '.inputCurve') # autoSquash setup autoNodeDesc = 'rbnAutoSquash' + side mdvAutoNodeName = mc.createNode('multiplyDivide', n=autoSquashName + '_' + autoNodeDesc + '_mdv') addAutoNodeName = mc.createNode('addDoubleLinear', n=autoSquashName + '_' + autoNodeDesc + '_add') multAutoNodeName = mc.createNode('multDoubleLinear', n=autoSquashName + '_' + autoNodeDesc + '_mult') mc.setAttr(addAutoNodeName + '.input2', -1) mc.setAttr(mdvAutoNodeName + '.operation', 2) # midCtrl setup mc.addAttr(midCtrl, ln='autoSquash', at='double', min=0, max=1, dv=0, k=True) mc.addAttr(midCtrl, ln='squash', at='double', dv=0, k=True) mc.connectAttr(midCtrl + '.autoSquash', multAutoNodeName + '.input2') # autoSquash connect mc.connectAttr(cifAutoGlobalNode + '.arcLength', mdvAutoNodeName + '.input1.input1X') mc.connectAttr(cifAutoNode + '.arcLength', mdvAutoNodeName + '.input2.input2X') mc.connectAttr(mdvAutoNodeName + '.output.outputX', addAutoNodeName + '.input1') mc.connectAttr(addAutoNodeName + '.output', multAutoNodeName + '.input1') for i in range(0, len(skinJntNameList)): # setup mdv, pma Node squashName = skinJntNameList[i].split('_')[0] mdvNodeName = squashName + '_rbnSquash' + side + '_mdv' pmaNodeName = squashName + '_rbnSquash' + side + '_pma' mc.createNode('multiplyDivide', n=mdvNodeName) mc.createNode('plusMinusAverage', n=pmaNodeName) mc.setAttr(pmaNodeName + '.input2D[0].input2Dx', 1) mc.setAttr(mdvNodeName + '.input2X', squashRatio[i]) mc.setAttr(mdvNodeName + '.input2Y', squashRatio[i]) # connect mdv, pma Node mc.connectAttr(mdvNodeName + '.outputX', pmaNodeName + '.input2D[1].input2Dx') mc.connectAttr(mdvNodeName + '.outputY', pmaNodeName + '.input2D[2].input2Dx') mc.connectAttr(mdvNodeName + '.outputZ', pmaNodeName + '.input2D[3].input2Dx') mc.connectAttr(pmaNodeName + '.output2D.output2Dx', skinJntNameList[i] + '.scale.scaleX') mc.connectAttr(pmaNodeName + '.output2D.output2Dx', skinJntNameList[i] + '.scale.scaleZ') # dtlCtrl setup mc.addAttr(dtlCtrlList[i], ln='squash', at='double', dv=0, k=True) # dtlCtrl connect mc.connectAttr(dtlCtrlList[i] + '.squash', mdvNodeName + '.input1.input1Z') # dtlCtrl connect mc.connectAttr(midCtrl + '.squash', mdvNodeName + '.input1.input1Y') # midCtrl connect mc.connectAttr(multAutoNodeName + '.output', mdvNodeName + '.input1.input1X')
def testGetVtValue(self): cmds.file(new=True, force=True) cmds.group(name="group1", empty=True) mat = UsdMaya.WriteUtil.GetVtValue("group1.matrix", Sdf.ValueTypeNames.Matrix4d) self.assertEqual(mat, Gf.Matrix4d(1.0)) vec3f = UsdMaya.WriteUtil.GetVtValue("group1.scale", Sdf.ValueTypeNames.Vector3f) self.assertEqual(vec3f, Gf.Vec3f(1.0)) self.assertIsInstance(vec3f, Gf.Vec3f) vec3d = UsdMaya.WriteUtil.GetVtValue("group1.scale", Sdf.ValueTypeNames.Vector3d) self.assertEqual(vec3d, Gf.Vec3d(1.0)) self.assertIsInstance(vec3d, Gf.Vec3d) cmds.addAttr("group1", ln="myArray", dt="vectorArray") cmds.setAttr("group1.myArray", 3, (0, 1, 2), (1, 2, 3), (2, 3, 4), type="vectorArray") float3Array = UsdMaya.WriteUtil.GetVtValue("group1.myArray", Sdf.ValueTypeNames.Float3Array) self.assertEqual(float3Array, Vt.Vec3fArray([(0, 1, 2), (1, 2, 3), (2, 3, 4)])) point3Array = UsdMaya.WriteUtil.GetVtValue("group1.myArray", Sdf.ValueTypeNames.Point3dArray) self.assertEqual(point3Array, Vt.Vec3dArray([(0, 1, 2), (1, 2, 3), (2, 3, 4)])) # Strings can be strings, tokens, or asset paths. cmds.addAttr("group1", ln="myString", dt="string") cmds.setAttr("group1.myString", "a_b_c", type="string") string = UsdMaya.WriteUtil.GetVtValue("group1.myString", Sdf.ValueTypeNames.String) self.assertEqual(string, "a_b_c") token = UsdMaya.WriteUtil.GetVtValue("group1.myString", Sdf.ValueTypeNames.Token) # alas, this becomes a str in Python self.assertEqual(token, "a_b_c") token = UsdMaya.WriteUtil.GetVtValue("group1.myString", Sdf.ValueTypeNames.Asset) self.assertEqual(token, Sdf.AssetPath("a_b_c")) # Colors have display-to-linear conversion applied. cmds.addAttr("group1", ln="myColor", at="double3") cmds.addAttr("group1", ln="myColorX", p="myColor", at="double") cmds.addAttr("group1", ln="myColorY", p="myColor", at="double") cmds.addAttr("group1", ln="myColorZ", p="myColor", at="double") cmds.setAttr("group1.myColor", 0.5, 0.5, 0.5) color3f = UsdMaya.WriteUtil.GetVtValue("group1.myColor", Sdf.ValueTypeNames.Color3f) self.assertAlmostEqual(color3f[0], 0.2176376) vec3f = UsdMaya.WriteUtil.GetVtValue("group1.myColor", Sdf.ValueTypeNames.Vector3f) self.assertAlmostEqual(vec3f[0], 0.5)
def forearmTwistRig(color, rollGrpParent, fkArmJoint, ikArmJoint, suffix, name, prefix, lowerArm): print "START Building the " + suffix + " lower arm twists---------------------------------------" print "suffix = " + suffix print "name = " + name print "prefix = " + prefix print "lowerArm = " + lowerArm # create a nice name name = prefix + name + suffix if name.find("_") == 0: name = name.partition("_")[2] lowerarm = prefix + lowerArm + suffix driver_lowerarm = "driver_" + prefix + lowerArm + suffix driver_hand = "driver_hand_" + name numRolls = 0 for joint in [ "_twist_01", "_twist_02", "_twist_03", "_twist_04", "_twist_05", "_twist_06" ]: if cmds.objExists("driver_" + prefix + lowerArm + joint + suffix): numRolls = numRolls + 1 print "...There are a total of " + str(numRolls) + " to build." for i in range(int(numRolls)): print "...Building lower arm twist_0" + str(i + 1) driver_lowerarm_twist = "driver_" + prefix + lowerArm + "_twist_0" + str( i + 1) + suffix # create our roll group rollGrp = cmds.group(empty=True, name=lowerarm + "_roll_grp_0" + str(i + 1)) cmds.parent(rollGrp, "arm_sys_grp") # Make sure the twist joint is exactly at the hand and aimed at the lowerarm #NOTE if the "side" method Jeremy is using in here(name) is intended to handle more than just "l" and "r" then the move part of this must be re-written to handle that accordingly. '''if i == 0: const = cmds.parentConstraint(driver_hand, driver_lowerarm_twist, weight=1, mo=False, sr=["x","y","z"]) cmds.delete(const) cmds.select(driver_lowerarm_twist, r=True) if name == "l": cmds.move(-0.995369, 0, 0, driver_lowerarm_twist, r = True) else: cmds.move(0.995369, 0, 0, driver_lowerarm_twist, r = True) cmds.makeIdentity(driver_lowerarm_twist, r = 1, t = 1, s = 1, apply =True)''' # create a new heirarchy out of the driver skeleton driver_lowerarm_offset = cmds.duplicate( driver_lowerarm, po=True, name=driver_lowerarm + "_Offset_0" + str(i + 1))[0] cmds.parent(driver_lowerarm_offset, rollGrp) cmds.setAttr(driver_lowerarm_offset + ".rotateOrder", 1) cmds.setAttr(driver_lowerarm_offset + ".v", 1) driver_lowerarm_twist_offset = cmds.duplicate( driver_lowerarm_twist, po=True, name=driver_lowerarm_twist + "_Offset")[0] cmds.parent(driver_lowerarm_twist_offset, driver_lowerarm_offset) cmds.setAttr(driver_lowerarm_twist_offset + ".rotateOrder", 1) cmds.setAttr(driver_lowerarm_twist_offset + ".v", 1) driver_hand_offset = cmds.duplicate(driver_lowerarm_twist_offset, po=True, name=driver_hand + "_Offset_0" + str(i + 1))[0] const = cmds.parentConstraint(driver_hand, driver_hand_offset, weight=1, mo=False, sr=["x", "y", "z"]) cmds.delete(const) cmds.setAttr(driver_hand_offset + ".rotateOrder", 1) cmds.setAttr(driver_hand_offset + ".v", 1) # create the manual twist control if i == 0: twistCtrl = utils.createControl("circle", 15, lowerarm + "_twist_anim") else: twistCtrl = utils.createControl( "circle", 15, lowerarm + "_twist" + str(i + 1) + "_anim") cmds.setAttr(twistCtrl + ".ry", -90) cmds.setAttr(twistCtrl + ".sx", 0.8) cmds.setAttr(twistCtrl + ".sy", 0.8) cmds.setAttr(twistCtrl + ".sz", 0.8) cmds.makeIdentity(twistCtrl, r=1, s=1, apply=True) # move the manual control to the correct location constraint = cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrl)[0] cmds.delete(constraint) # create a group for the manual control and parent the twist to it. twistCtrlGrp = cmds.group(empty=True, name=twistCtrl + "_grp") constraint = cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrlGrp)[0] cmds.delete(constraint) cmds.parent(twistCtrl, twistCtrlGrp) cmds.parent(twistCtrlGrp, rollGrp) cmds.makeIdentity(twistCtrl, t=1, r=1, s=1, apply=True) cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrlGrp) # set the manual controls visibility settings cmds.setAttr(twistCtrl + ".overrideEnabled", 1) cmds.setAttr(twistCtrl + ".overrideColor", color) for attr in [".sx", ".sy", ".sz"]: cmds.setAttr(twistCtrl + attr, lock=True, keyable=False) cmds.setAttr(twistCtrl + ".v", keyable=False) # add attr on rig settings for manual twist control visibility cmds.select("Rig_Settings") if i == 0: cmds.addAttr(longName=(name + "twistCtrlVisLower"), at='bool', dv=0, keyable=True) cmds.connectAttr("Rig_Settings." + name + "twistCtrlVisLower", twistCtrl + ".v") # add attr to rig settings for the twist ammount values cmds.select("Rig_Settings") cmds.addAttr(longName=(name + "ForearmTwist" + str(i + 1) + "Amount"), defaultValue=0.5, minValue=0, maxValue=1, keyable=True) for u in range(int(i + 1)): cmds.setAttr( "Rig_Settings." + name + "ForearmTwist" + str(u + 1) + "Amount", (1.0 / (i + 2.0) * ((2.0 - u) + (i - 1.0)))) # Create a locator and group for the up vector of the aim for the twist. forearmTwistUp = cmds.spaceLocator(n="forearmTwistUp_0" + str(i + 1) + "_" + name)[0] constraint = cmds.parentConstraint(driver_hand_offset, forearmTwistUp)[0] cmds.delete(constraint) forearmTwistUpGrp = cmds.duplicate(driver_hand_offset, po=True, name=forearmTwistUp + "_grp")[0] cmds.parent(forearmTwistUpGrp, rollGrp) cmds.parent(forearmTwistUp, forearmTwistUpGrp) cmds.setAttr(forearmTwistUpGrp + ".rotateOrder", 1) cmds.setAttr(forearmTwistUp + ".v", 0) # constrain the up group into the rig so that it takes the correct ammount of the twist forearmGrpPrntConst = cmds.parentConstraint(driver_lowerarm_offset, driver_hand_offset, forearmTwistUpGrp, mo=True)[0] cmds.setAttr(forearmGrpPrntConst + ".interpType", 2) cmds.move(0, 0, 6, forearmTwistUp, r=True) twistAimConst = cmds.aimConstraint(driver_hand_offset, driver_lowerarm_twist_offset, weight=1, mo=True, aimVector=(1, 0, 0), upVector=(0, 0, 1), worldUpType="object", worldUpObject=forearmTwistUp)[0] # constrain the offsets back to the original driver skeleton cmds.parentConstraint(driver_hand, driver_hand_offset, mo=True) cmds.parentConstraint(driver_lowerarm, driver_lowerarm_offset, mo=True) # hook up the nodes to drive the twist based on the values on the rig settings node. reverseNode = cmds.shadingNode("reverse", asUtility=True, name=forearmGrpPrntConst + "_reverse") cmds.connectAttr("Rig_Settings." + name + "ForearmTwist" + str(i + 1) + "Amount", forearmGrpPrntConst + "." + driver_hand_offset + "W1", f=True) cmds.connectAttr("Rig_Settings." + name + "ForearmTwist" + str(i + 1) + "Amount", reverseNode + ".inputX", f=True) cmds.connectAttr(reverseNode + ".outputX", forearmGrpPrntConst + "." + driver_lowerarm_offset + "W0", f=True) #constrain driver joint to twist joint cmds.parentConstraint(twistCtrl, driver_lowerarm_twist, mo=True) print ".END Building the " + suffix + " lower arm twists---------------------------------------"
def lidSurface_create(curveList, spans=4, attributeObject='', collisionObject='', side='', prefix=''): """ Generate a lidSurface setup from the specified curve list and input parameters @param curveList: List of curves to generate the lidSurface from @type curveList: list @param spans: Number of verticle spans form each lid surface @type spans: int @param attributeObject: Object that will hold attributes form manipulating the lidSurface node @type attributeObject: str @param collisionObject: Nurbs surface object that will be used as a collision object for the lid surfaces @type collisionObject: str @param side: The side of the face the eyelid is on. ("lf" or "rt") @type side: str @param prefix: Name prefix for all created nodes @type prefix: str """ # NameUtil nameUtil = gLib.common.namingConvention.NamingConvention() # Check prefix if not prefix: prefix = nameUtil.stripSuffix(crvList[0], '_') # Check side if not side: side = prefix.split('_')[0] # Check curveList for crv in curveList: if not cmds.objExists(crv): raise UserInputError('Curve "' + crv + '" does not exist!') if not gLib.rig.utilities.curve.isCurve(crv): raise UserInputError('Object "' + crv + '" is not a valid nurbs curve!') # Create lidSurface node lidSurface = nameUtil.appendName(prefix, nameUtil.node['lidSurface']) lidSurface = cmds.createNode('lidSurface', n=lidSurface) # Set spans cmds.setAttr(lidSurface + '.spans', spans) # Connect curevList for i in range(len(curveList)): cmds.connectAttr(curveList[i] + '.worldSpace', lidSurface + '.inputCurve[' + str(i) + ']', f=True) # Check Attribute Object if cmds.objExists(attributeObject): # Check attributes if not cmds.objExists(attributeObject + '.' + side + 'TopLid'): cmds.addAttr(attributeObject, ln=side + 'TopLid', min=-1, max=1, dv=0, k=True) if not cmds.objExists(attributeObject + '.' + side + 'LowLid'): cmds.addAttr(attributeObject, ln=side + 'LowLid', min=-1, max=1, dv=0, k=True) if not cmds.objExists(attributeObject + '.' + side + 'LidMeet'): cmds.addAttr(attributeObject, ln=side + 'LidMeet', min=0, max=1, dv=0.5, k=True) # Connect Attributes cmds.connectAttr(attributeObject + '.' + side + 'TopLid', lidSurface + '.top', f=True) cmds.connectAttr(attributeObject + '.' + side + 'LowLid', lidSurface + '.bottom', f=True) cmds.connectAttr(attributeObject + '.' + side + 'LidMeet', lidSurface + '.split', f=True) # Check Collision Object if cmds.objExists(collisionObject): if not gLib.rig.utilities.surface.isSurface(collisionObject): raise UserInputError('Collision object "' + crv + '" is not a valid nurbs surface!') # cmds.connectAttr(collisionObject+'.worldMatrix[0]',lidSurface+'.collisionMatrix',f=True) cmds.connectAttr(collisionObject + '.worldSpace', lidSurface + '.collisionGeometry', f=True) # Create lid surfaces topLid_srf = nameUtil.appendName(prefix + '_tp01', nameUtil.node['surface']) topLid_srf = cmds.nurbsPlane(ch=0, n=topLid_srf)[0] lowLid_srf = nameUtil.appendName(prefix + '_lw01', nameUtil.node['surface']) lowLid_srf = cmds.nurbsPlane(ch=0, n=lowLid_srf)[0] # Attach lid surfaces cmds.connectAttr(lidSurface + '.topLidSurface', topLid_srf + '.create', f=True) cmds.connectAttr(lidSurface + '.lowLidSurface', lowLid_srf + '.create', f=True) # Return result return (topLid_srf, lowLid_srf)
def create(geo, prefix=''): """ """ # Check prefix if not prefix: prefix = geo # Create Deformer sMod = cmds.softMod(geo, n=prefix + '_softMod') sModHandle = sMod[1] sMod = sMod[0] sModBase = cmds.duplicate(sModHandle, po=True, n=prefix + '_softModBase')[0] # Get Handle pivot piv = cmds.xform(sModHandle, q=True, ws=True, rp=True) # Initiate Control Builder ctrlBuilder = glTools.tools.controlBuilder.ControlBuilder() # Create Base control base_grp = cmds.createNode('transform', n=prefix + '_softModBase_grp') base_ctrl = cmds.createNode('transform', n=prefix + '_softModBase_ctrl', p=base_grp) base_ctrlShape = ctrlBuilder.controlShape(base_ctrl, 'box', scale=2) # Create Offset control offset_grp = cmds.createNode('transform', n=prefix + '_softModOffset_grp', p=base_ctrl) offset_ctrl = cmds.createNode('transform', n=prefix + '_softModOffset_ctrl', p=offset_grp) offset_ctrlShape = ctrlBuilder.controlShape(offset_ctrl, 'sphere', scale=0.25) # Create Falloff control falloff_grp = cmds.createNode('transform', n=prefix + '_softModFalloff_grp', p=base_ctrl) falloff_ctrl = cmds.createNode('transform', n=prefix + '_softModFalloff_ctrl', p=falloff_grp) falloff_ctrlShape = ctrlBuilder.controlShape(falloff_ctrl, 'circle', scale=1) falloff_loc = cmds.spaceLocator(n=prefix + '_softModFalloff_loc')[0] cmds.parent(falloff_loc, falloff_ctrl) cmds.addAttr(falloff_ctrl, ln='radius', min=0.001, dv=1, k=True) cmds.setAttr(falloff_loc + '.v', 0) # Move hierarchy into place cmds.move(piv[0], piv[1], piv[2], base_grp, a=True) # Connect to deformer cmds.connectAttr(falloff_loc + '.worldPosition[0]', sMod + '.falloffCenter', f=True) cmds.connectAttr(falloff_ctrl + '.radius', sMod + '.falloffRadius', f=True) cmds.connectAttr(sModBase + '.worldInverseMatrix[0]', sMod + '.bindPreMatrix', f=True) # Parent and constrain softMod elements cmds.parentConstraint(offset_ctrl, sModHandle, mo=True) cmds.scaleConstraint(offset_ctrl, sModHandle, mo=True) cmds.parentConstraint(base_ctrl, sModBase, mo=True) cmds.scaleConstraint(base_ctrl, sModBase, mo=True) cmds.parent(sModHandle, sModBase) cmds.parent(sModBase, base_grp) # Return result return sMod