def cameraFrustum_build(cam_shape): #make sure a camera is loaded if cam_shape==0: cmds.error('no camera loaded...select a camera and load') else: #create frustum only if one doesnt already exist selCamXform = cmds.listRelatives(cam_shape[0], p=1) prefix = 'frust_' frustumGrpName = prefix + 'camera_frustum_all_grp' if cmds.objExists(frustumGrpName)==0: #create main grp frustumMainGrp = cmds.group(em=1, n=frustumGrpName); cmds.setAttr(frustumGrpName + '.tx', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.ty', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.tz', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.rx', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.ry', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.rz', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.sx', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.sy', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.sz', lock=1, keyable=0, channelBox=0) cmds.setAttr(frustumGrpName + '.v', lock=1, keyable=0, channelBox=0) #create frustum geo frustumGeo = cmds.polyCube(w=2, h=2, d=2, n=prefix + 'camera_frustum_geo') cmds.delete(frustumGeo[0], constructionHistory=True) cmds.parent(frustumGeo[0], frustumMainGrp) #load plugin "nearestPointOnMesh.mll" if needed and connect plugin = cmds.pluginInfo('nearestPointOnMesh.mll', q=1, l=1) if plugin==0: cmds.loadPlugin('nearestPointOnMesh.mll') nearNodeName = prefix + 'npomNode' npomNode = cmds.createNode('nearestPointOnMesh', n=nearNodeName) cmds.connectAttr(frustumGeo[0] + '.worldMesh', npomNode + '.inMesh') #create clusters cmds.select(frustumGeo[0] + '.vtx[4:7]', r=1) nearCluster = cmds.cluster(n=prefix + 'camera_nearFrustum_cluster') cmds.select(frustumGeo[0] + '.vtx[0:3]', r=1) farCluster = cmds.cluster(n=prefix + 'camera_farFrustum_cluster') #create near/far/camera locs cameraLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_loc') cmds.parent(cameraLoc[0], frustumMainGrp) nearLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_nearFrustum_loc') cmds.move(0, 0, -1) farLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_farFrustum_loc') cmds.move(0, 0, 1) #parent clusters under loc -- parent locs under camera loc cmds.parent(nearCluster[1], nearLoc[0]) cmds.parent(farCluster[1], farLoc[0]) cmds.parent(nearLoc[0], cameraLoc[0]) cmds.parent(farLoc[0], cameraLoc[0]) #constrain camera loc to camera cmds.parentConstraint(selCamXform, cameraLoc, weight=1) return frustumGeo[0]
def __init__(self, objs = [], vertices = []): self.objs = objs self.vertices = vertices #lattice -divisions 2 3 2 -objectCentered true -ol 1; #mc.select( self.objs, self.vertices ) #CREATION grp = mn.Node( mc.group( n = "head_toon_GRP", em = True ) ) deGrp = mn.Node( mc.group( n = "head_toon_deformer_GRP", em = True ) ) deGrp.parent = grp deGrp.a.v.v = False deGrp.a.v.locked = True latNods = mc.lattice( self.objs, self.vertices, divisions = [ 2,3,2], objectCentered = True, ol = 1, n = 'head_toon_LAT' ) latBase = mn.Node( latNods[2] ) latBase.parent = deGrp lat = mn.Node( latNods[1] ) lat.parent = deGrp #mc.select( lat + ".pt[0:1][2][0]", lat + ".pt[0:1][2][1]" ) topClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][2][0]", lat.shape.name + ".pt[0:1][2][1]", n = 'top_face_toon_CLU' )[1] ) topClus.a.v.v = False topClus.a.v.locked = True #mc.select( lat + ".pt[0:1][1][0]", lat + ".pt[0:1][1][1]" ) midClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][1][0]", lat.shape.name + ".pt[0:1][1][1]", n = 'mid_face_toon_CLU' )[1] ) #mc.select( lat + ".pt[0:1][0][0]", lat + ".pt[0:1][0][1]" ) lowClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][0][0]", lat.shape.name + ".pt[0:1][0][1]", n = 'low_face_toon_CLU' )[1] ) ctl = crv.Curve( "head_toon_CTL" ) ctl = ctl.create( "sphere" ) ctl.a.t.v = topClus.worldPosition mc.makeIdentity( ctl.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) topClus.parent = ctl midClus.parent = deGrp lowClus.parent = deGrp ctl.parent = grp #CONSTRAINS midClus.a.r >> topClus.a.r mc.pointConstraint( topClus.name, lowClus.name, midClus.name, mo = True ) #SCALE FOR MID CLUSTER dist = mn.createNode( 'distanceBetween', n = 'head_toon_DIS' ) ctl.a.worldMatrix >> dist.a.inMatrix1 ctl.a.rp >> dist.a.point1 lowClus.a.worldMatrix >> dist.a.inMatrix2 lowClus.a.rp >> dist.a.point2 mul = mn.createNode( 'multiplyDivide', n = 'head_toon_scale_MUL' ) mul.a.input1.v = [dist.a.distance.v]*3 mul.a.operation.v = 2 dist.a.distance >> mul.a.input2X dist.a.distance >> mul.a.input2Y dist.a.distance >> mul.a.input2Z mul.a.output >> midClus.a.s #AIM CONSTRAINT upLocGrp = mn.Node( mc.group( n = "head_upVector_GRP", em = True ) ) upLocGrp.a.t.v = midClus.worldPosition mc.makeIdentity( upLocGrp.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) upLocGrp.parent = deGrp mc.orientConstraint( ctl.name, lowClus.name, upLocGrp.name, mo = True ) upLoc = mn.Node( mc.spaceLocator( n = 'head_upVector_LOC' )[0] ) upLoc.a.t.v = midClus.worldPosition upLoc.a.tz.v = upLoc.a.tz.v + 5 mc.aimConstraint( topClus.name, midClus.name, mo = True, weight = 1, aimVector = [1, 0, 0], upVector = [0, 1, 0], worldUpType = "object", worldUpObject = upLoc.name ) upLoc.parent = upLocGrp mc.pointConstraint( topClus.name, lowClus.name, upLoc.name, mo = True )
def autoEyebrowGuidePosition(side = None, guideName = None): objectName = side + "_" + guideName sel = cmds.ls(os = 1, flatten = 1) pos = [] cluster = [] # check which type of component is selected and store the position for t in sel: i = t selType = t.split(".")[1][0] if selType == "e": vtx = cmds.polyListComponentConversion(i, fe = 1, tv = 1) cmds.select(vtx) cls = cmds.cluster() clsPos = cmds.xform(cls, query = 1, rotatePivot = 1, worldSpace = 1) pos.append(clsPos) cluster.append(cls) elif selType == "f": vtx = cmds.polyListComponentConversion(i, ff = 1, tv = 1) cmds.select(vtx) cls = cmds.cluster() clsPos = cmds.xform(cls, query = 1, rotatePivot = 1, worldSpace = 1) pos.append(clsPos) cluster.append(cls) elif selType == "v": cmds.warning("Select in another component mode! We are out of verts dude!!!") else: cmds.warning("No components selected dude!!!") # check if guide group exists if cluster: if cmds.objExists(objectName + "_TRN"): cmds.delete(objectName + "_TRN") # create the guides guides = defGuideCmds.defGuideCrv() guides.__init__(nSpans = len(cluster)-1, curveDegree = 1, offset =.2, offsetVector = [1,0,0], side = side, name = guideName, startPosition = [0,0,0], ctlSize = 10) cmds.delete("C_curve_TRN") # delete the cluster for c in cluster: cmds.delete(c) # list all the guides inside the guideName group except the curve loc = cmds.listRelatives(objectName + "_TRN", allDescendents = 1, type = "transform")[:-1] # reposition the guides at the vertices place for i, p in zip(loc, pos): cmds.xform(i, translation = p, worldSpace = 1) # mirror the guides cmds.select(loc) guides.createMirror()
def __createPoleVectorCtl(self, ankleHandle): poleVectorCtl = self.importCtl('pole_vector_Ctl') poleVectorGrp = self.uuid('pole_vector_Grp') mc.rename('pole_vector_Grp', poleVectorGrp) theta = 0.4 if '_F_' in self._rootJointShortName or '_M_' in self._rootJointShortName: mc.setAttr(poleVectorCtl + '.scaleZ', -1) mc.makeIdentity(poleVectorCtl, apply=True, t=True, r=True, s=True, normal=0, preserveNormals=True) theta = 0.8 # make sure the poleVectorCtl on the same plane of ankle joint chain p0 = om.MVector(mc.xform(self._jointChain[0], q=True, t=True, ws=True)) p1 = om.MVector(mc.xform(self._jointChain[1], q=True, t=True, ws=True)) p2 = om.MVector(mc.xform(self._jointChain[2], q=True, t=True, ws=True)) d0 = om.MVector(p1 - p0).normal() d1 = om.MVector(p1 - p2).normal() pos = p2 + (d0 + d1) * theta self._move(poleVectorGrp, [pos.x, pos.y, pos.z], False) # link pole vector start point to the ankle joint curveCtl = self.uuid('curveCtl') mc.curve(n=curveCtl, degree=1, p=[(0, 0, 0), (0, 0, 0)]) clusterStartHandle = mc.cluster('%s.cv[0]' % curveCtl, n=self.uuid('clusterStart'), envelope=1) mc.pointConstraint(ankleHandle, clusterStartHandle, offset=(0, 0, 0), weight=1.0) clusterEndHandle = mc.cluster('%s.cv[1]' % curveCtl, n=self.uuid('clusterEnd'), envelope=1) mc.pointConstraint(poleVectorCtl, clusterEndHandle, offset=(0, 0, 0), weight=1.0) mc.makeIdentity(poleVectorGrp, apply=True, t=True, r=True, s=True, normal=0, preserveNormals=True) mc.parent(clusterStartHandle, clusterEndHandle, curveCtl, poleVectorGrp) return poleVectorCtl, poleVectorGrp
def RMCreateClustersOnCurve(self , curve = None): if curve.__class__ in [str,unicode]: masterCurve = curve mode = "single" #print ("degree:%s",degree) #print ("spans:%s",spans) #print ("form:%s",form) elif curve.__class__ == list: masterCurve = curve[0] mode = "multi" degree = cmds.getAttr (masterCurve + ".degree") spans = cmds.getAttr (masterCurve + ".spans") form = cmds.getAttr (masterCurve + ".form") # Form (open = 0, closed = 1, periodic = 2) clusterList=[] if form == 0 or form ==1: #print "Open Line" for i in range(0 , (degree + spans)): cluster = cmds.cluster(masterCurve + ".cv["+str(i)+"]",name=self.NameConv.RMUniqueName ("Character_MD_ClusterOnCurve_cls_rig")) if mode == "multi": self.RMAddToCluster(i , curve[1:],cluster) clusterList.append(cluster[1]) cmds.setAttr(cluster[1]+".visibility",0) ##cmds.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]") if form == 2: #print "periodic Line" for i in range(0,spans): cluster = cmds.cluster(masterCurve+".cv["+str(i)+"]" ,name = self.NameConv.RMUniqueName ("Character_MD_ClusterOnCurve_cls_rig")) if mode == "multi": self.RMAddToCluster(i , curve[1:], cluster) clusterList.append(cluster[1]) cmds.setAttr(cluster[1]+".visibility",0) #cmds.cluster(cluster,edit=True,geometry = curve + ".["+str(i)+"]") return clusterList
def curveBetweenPoints( pointA, pointB, prefix = 'new', constrainCurve = False ): ''' creates curve from between two transform nodes or [ x,y,z ] @param pointA: str, name of transform node or [linear, linear, linear] @param pointB: str, name of transform node or [linear, linear, linear] @param prefix: str, prefix for naming objects @param contrainCurve: bool, constrain the curve with weighted cluster @return: list(str), curve object ''' xforms = [ pointA, pointB ] for xform in xforms: if len( xform ) > 3: xform = mc.xform( xform, q = 1, t = 1, ws = 1 ) abCurve = mc.curve( n = prefix + '_crv',d =1, p = [xforms[0],xforms[1]] ) if constrainCurve: mc.cluster(abCurve + '.cv[0]', n = prefix + 'crvPointA_cls', wn = [pointA, pointA], bs =1) mc.cluster(abCurve + '.cv[1]', n = prefix + 'crvPointB_cls', wn = [pointB, pointB], bs =1) return abCurve
def ikSpline_transfer(first, second, up_src_jnt, low_src_jnt): """ Create a spline Ik-Handle with the Ik-SplineHandleTool from the supplied spine joints. It will create 2 cluster paired to the cvs of the driving crv, these clusters will get contrained to the given src_jnts. One for the upper cluster and one for the lower. Args: irst ([Str]): Start joint. second ([Str]): End joint. up_src_jnt ([Str]): Src joint to drive upper cluster. low_src_jnt ([Str]): Src joint to drive lower cluster. """ # create ik spline handle res = cmds.ikHandle(sj=first, ee=second, sol="ikSplineSolver", pcv=False, ns=4) sp_handle, sp_effector, sp_curve = res deg = cmds.getAttr('{0}.degree'.format(sp_curve)) spans = cmds.getAttr('{0}.spans'.format(sp_curve)) cmds.select("{0}.cv[0:{1}]".format(sp_curve, deg)) cmds.select("{0}.cv[{1}:]".format(sp_curve, spans)) # create cluster for upper and lower region low_cl_name, low_cl_handle = cmds.cluster( "{0}.cv[0:{1}]".format(sp_curve, deg)) up_cl_name, up_cl_handle = cmds.cluster( "{0}.cv[{1}:]".format(sp_curve, spans)) # contraint ik spline to joints for jnt, hndl in [(up_src_jnt, up_cl_handle), (low_src_jnt, low_cl_handle)]: cmds.parentConstraint(jnt, hndl, mo=True) cmds.parentConstraint(up_src_jnt, up_cl_handle, mo=True) cmds.parentConstraint(low_src_jnt, low_cl_handle, mo=True)
def transferCluster(source, target, deformer, handle=False, surfaceAssociation="closestPoint", createNew=True): ''' This will transfer cluster from one mesh to another. If the target doesn't have a cluster on it, it will create a new cluster. Then once there is a cluster We will copy weights over. :param source: The geomertry you are transfer from :type source: str :param target: The geometry you want to transfer to :type target: str | list :param surfaceAssociation: How to copy the weights from source to target available values are "closestPoint", "rayCast", or "closestComponent" :type surfaceAssociation: str ''' # do some error checking if not mc.objExists(source): raise RuntimeError('The source mesh "{}" does not exist in the current Maya session.'.format(source)) if not isinstance(surfaceAssociation, basestring): raise TypeError('The surfaceAssociation argument must be a string.') if deformer: if not mc.objExists(deformer): raise RuntimeError("{} doesn't exist in the current Maya session!".format(deformer)) # first we will turn the target into a list if it's not already a list meshList = rigrepo.libs.common.toList(target) # make sure we have a cluster on the source mesh clusterList = list() for mesh in meshList: if not mc.objExists(mesh): mc.warning('The target mesh "{}" does not exist in the current Maya session.'.format(target)) continue # check to see if there is a cluster already on the target mesh hist = [node for node in mc.listHistory(mesh, pdo=True, lv=1) if mc.nodeType(node) == "cluster"] # if there is no cluster, we will create one. newDeformer = "{}__{}".format(mesh, deformer) if deformer not in hist and not createNew: mc.sets(mc.ls("{}.cp[*]".format(mesh))[0], e=True, add="{}Set".format(deformer)) newDeformer = deformer elif createNew: if not newDeformer in hist: if handle: clsHandle = mc.cluster(deformer, q=True, wn=True) mc.cluster(mesh, name=newDeformer, wn=[clsHandle, clsHandle], bs=True) else: mc.cluster(mesh, name=newDeformer, bs=True) else: newDeformer = deformer clusterList.append(newDeformer) # now we will transfer the wts mc.copyDeformerWeights(ss=source, ds=mesh, sd=deformer, dd=newDeformer, sa=surfaceAssociation, noMirror=True) return clusterList
def create_line(obj_from="", obj_to="", prefix="", rigModule=None): """ Create a template line between two objects @param obj_from: str, object that the line should start from @param obj_to: str, object that the line end at @param prefix: str, prefix to name new objects @param rigModule: instance of base.module.Module class @return: str, name of the curve """ pos1 = mc.xform(obj_from, q=1, t=1, ws=1) pos2 = mc.xform(obj_to, q=1, t=1, ws=1) crv = mc.curve(n=prefix + 'Line_crv', d=1, p=[pos1, pos2]) cls1 = mc.cluster(crv + '.cv[0]', n=prefix + 'Line1_cls', wn=[obj_from, obj_from], bs=True) cls2 = mc.cluster(crv + '.cv[1]', n=prefix + 'Line2_cls', wn=[obj_to, obj_to], bs=True) mc.setAttr(crv + '.template', 1) offset_grp = mc.createNode("transform", name=prefix + 'CrvOffset_grp') mc.setAttr(offset_grp + '.inheritsTransform', 0) mc.parent(crv, offset_grp) mc.parent(offset_grp, rigModule.controlsGrp) return {'crv': crv, 'grp': offset_grp}
def connect_with_line(self, start='', end=''): ''' create a line in between 2 transforms (start and end) ''' if start == '': sel = cmds.ls(sl=True) start = sel[0] end = sel[1] #create line cv = self.curve_between(start=start, end=end) cv = cmds.rename( cv, '{}_{}{}{}'.format(start, end, nc['connected'], nc['curve'])) #create clusters on cvs 0 and 1 cmds.select('{}.cv[0]'.format(cv)) cluster_start = cmds.cluster(n='{}{}'.format(start, nc['cluster'])) cmds.select('{}.cv[1]'.format(cv)) cluster_end = cmds.cluster(n='{}{}'.format(end, nc['cluster'])) #create aprents constrains to clusters cmds.parentConstraint(start, cluster_start) cmds.parentConstraint(end, cluster_end) #clean and hide cv and clusters cmds.setAttr("{}.overrideEnabled".format(cv), 1) cmds.setAttr("{}.overrideDisplayType".format(cv), 2) cmds.setAttr('{}.v'.format(cluster_start[1]), 0) cmds.setAttr('{}.v'.format(cluster_end[1]), 0) connect_with_line_assets = [cv, cluster_start[1], cluster_end[1]] return connect_with_line_assets
def create_polevector_follow(control, joint): """Creates a linear curve between a joint and a control.""" # world space joint_world_space = cmds.xform(control, q=True, ws=True, rp=True) control_world_space = cmds.xform(joint, q=True, ws=True, rp=True) # create curve and clusters curve = cmds.curve(d=1, p=[joint_world_space, control_world_space], n="{0}_curve".format(control)) cmds.setAttr("{0}.overrideEnabled".format(curve), 1) cmds.setAttr("{0}.overrideDisplayType".format(curve), 1) joint_cluster = cmds.cluster("{0}.cv[0]".format(curve), n="{0}_cluster".format(joint)) control_cluster = cmds.cluster("{0}.cv[1]".format(curve), n="{0}_cluster".format(control)) # set hierarchy groupNode = cmds.group(joint_cluster, control_cluster, curve, n=curve + "_grp") cmds.parent(groupNode, "rig_grp") cmds.parentConstraint(control, joint_cluster, mo=False) cmds.parentConstraint(joint, control_cluster, mo=False) # hide cmds.hide(joint_cluster) cmds.hide(control_cluster)
def RMCreateLineBetwenPoints (self, Point1, Point2): Curve = cmds.curve (degree=1, p=[[0,0,0],[1,0,0]], name = "curveLineBetweenPnts") Curve = self.NameConv.RMRenameBasedOnBaseName(Point1, Curve, NewName = Curve) NumCVs = cmds.getAttr (Curve + ".controlPoints" , size = True) Cluster1, Cluster1Handle = cmds.cluster (Curve+".cv[0]", relative=True, name = "clusterLineBetweenPnts") Cluster1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1, NewName = Cluster1) Cluster1Handle = self.NameConv.RMRenameBasedOnBaseName(Point1 , Cluster1Handle, NewName = Cluster1Handle) Cluster2, Cluster2Handle = cmds.cluster (Curve+".cv[1]", relative=True, name = "clusterLineBetweenPnts") Cluster2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2, NewName = Cluster2) Cluster2Handle = self.NameConv.RMRenameBasedOnBaseName(Point2 , Cluster2Handle, NewName = Cluster2Handle) cmds.setAttr(Curve+".overrideEnabled",1) cmds.setAttr(Curve+".overrideDisplayType",1) RMAlign (Point1, Cluster1Handle, 1) RMAlign (Point2, Cluster1Handle, 1) PointConstraint1 = cmds.pointConstraint (Point1, Cluster1Handle, name = "PointConstraintLineBetweenPnts")[0] PointConstraint1 = self.NameConv.RMRenameBasedOnBaseName(Point1 , PointConstraint1, NewName = PointConstraint1) PointConstraint2 = cmds.pointConstraint (Point2, Cluster2Handle, name = "PointConstraintLineBetweenPnts")[0] PointConstraint2 = self.NameConv.RMRenameBasedOnBaseName(Point2 , PointConstraint2, NewName = PointConstraint2) DataGroup = cmds.group (em = True,name = "DataLineBetweenPnts") DataGroup = self.NameConv.RMRenameBasedOnBaseName(Point1 , DataGroup, NewName = DataGroup) cmds.parent (Cluster1Handle, DataGroup) cmds.parent (Cluster2Handle, DataGroup) cmds.parent (Curve, DataGroup) return DataGroup , Curve
def makePoleVectorLine(name, joint, poleVector): """ Description: make visual line to connect pv and limb name: prefix to name joint: limb to attach poleVector: pv to attach, (instance of object) return value: polevector curve to parent to X group """ pv_line_pos_1 = mc.xform(joint, q=True, t=True, ws=True) pv_line_pos_2 = mc.xform(poleVector.control, q=True, t=True, ws=True) poleVector_curve = mc.curve(n=name + '_pv_crv', degree=1, point=[pv_line_pos_1, pv_line_pos_2]) mc.cluster(poleVector_curve + '.cv[0]', n=name + '_pv1_cls', weightedNode=[joint, joint], bindState=True) mc.cluster(poleVector_curve + '.cv[1]', n=name + '_pv2_cls', weightedNode=[poleVector.control, poleVector.control], bindState=True) mc.setAttr(poleVector_curve + '.template', True) mc.setAttr(poleVector_curve + '.it', False) return poleVector_curve
def createCurveBetweenVertex(): target = mc.ls(sl=True,fl=True) global newCurve if(len(target)!=2): mc.warning("Choose Two Point or Object") else: sourcePos = mc.xform(target[0],q=True,ws=True,t=True) targetPos = mc.xform(target[1],q=True,ws=True,t=True) pointCurve = mc.curve(p=(sourcePos,targetPos),ws=True,d=1) newCurve.append(pointCurve) cluster1 = mc.cluster(pointCurve+'.cv[0]') newCurve.append(cluster1[1]) mc.setAttr(cluster1[1]+'.visibility',0) cluster2 = mc.cluster(pointCurve+'.cv[1]') newCurve.append(cluster2[1]) mc.setAttr(cluster2[1]+'.visibility',0) mc.select(clear=True) mc.select(target[0],cluster1[1]) mel.eval('doCreatePointOnPolyConstraintArgList 2 { "0" ,"0" ,"0" ,"1" ,"" ,"1" ,"0" ,"0" ,"0" ,"0" };') mc.select(clear=True) mc.select(target[1],cluster2[1]) mel.eval('doCreatePointOnPolyConstraintArgList 2 { "0" ,"0" ,"0" ,"1" ,"" ,"1" ,"0" ,"0" ,"0" ,"0" };')
def create_ik(self): """Ik spline""" # Create curve tmp_curve = curve.create_from_nodes(self.joints, name=name.set_suffix(self.name, 'ikCrv'), degree=3) self.curve = curve.rebuild_curve(tmp_curve, 3)[0] start_joint, end_joint = self.ik_joints[0], self.ik_joints[-1] logger.info("Creating Ik using nodes: %s" % self.joints) self.ik, self.effector = cmds.ikHandle(name=name.set_suffix(self.name, 'ikh'), sj=start_joint, ee=end_joint, curve=self.curve, createCurve=False, sol="ikSplineSolver", ns=3) # Add to setups self.setups.extend([self.ik, self.curve]) # Set attrs cmds.setAttr("%s.dTwistControlEnable" % self.ik, 1) cmds.setAttr("%s.dWorldUpAxis" % self.ik, 1) cmds.setAttr("%s.dWorldUpType" % self.ik, 4) cmds.setAttr("%s.dWorldUpVector" % self.ik, 1.0, 0.0, 0.0, type="float3") cmds.setAttr("%s.dWorldUpVectorEnd" % self.ik, 1.0, 0.0, 0.0, type="float3") # Turn on cvs cmds.select(self.curve, r=True) cmds.toggle(cv=True) # Create clusters clusters = OrderedDict() clusters['bot'] = cmds.cluster(["%s.cv[0]" % self.curve, "%s.cv[1]" % self.curve])[1] clusters['mid'] = cmds.cluster(["%s.cv[2]" % self.curve, "%s.cv[3]" % self.curve])[1] clusters['top'] = cmds.cluster(["%s.cv[4]" % self.curve, "%s.cv[5]" % self.curve])[1] xform.match_pivot(start_joint, clusters['bot']) xform.match_pivot(end_joint, clusters['top']) self.clusters = clusters
def rebuild(self): ''' Rebuild the cluster deformer from the recorded deformerData ''' # Check target geometry for obj in self.deformerData.iterkeys(): if not mc.objExists(obj): raise UserInputError('Object '+obj+' does not exist!') # Check deformer if mc.objExists(self.deformerName): raise UserInputError('Cluster '+self.deformerName+' already exists!') # Rebuild deformer cluster = None if mc.objExists(self.handle): cluster = mc.cluster(self.getMemberList(),n=self.deformerName,wn=(self.handle,self.handle)) else: cluster = mc.cluster(self.getMemberList(),n=self.deformerName) if cluster[1] != self.handle: mc.rename(cluster[1],self.handle) deformer = cluster[0] # Connect bindPreMatrix if self.bindPreMatrix: if mc.objExists(self.bindPreMatrix[0]): mc.connectAttr(self.bindPreMatrix[0],cluster+'.bindPreMatrix') # Connect geomMatrix for conn in self.geomMatrix.iterkeys(): if mc.objExists(conn): mc.connectAttr(conn+'.'+self.geomMatrix[conn][0],cluster+'.geomMatrix['+str(self.geomMatrix[conn][1])+']') # Set cluster weights self.loadWeights() # Return result return deformer
def parent_cluster(cluster_name): cluster_parent = cmds.textField('UI_cluster_clusterName', q=True, tx=True) cluster_parent = cluster_parent.replace (" ", "_") cluster_parent = cmds.createNode( 'transform', n= 'trn_' + cluster_parent, ss=True) centre = cmds.objectCenter("loc_guide_deformer", gl=True) cmds.move(centre[0], centre[1], centre[2], cluster_parent) cmds.cluster (name = cluster_name, bs = True, wn = (cluster_parent, cluster_parent)) cmds.delete("loc_guide_deformer")
def crvGuide( ctrl = '' , target = '' ) : # Create NURBs curve between control and target # Returns : curve and two clusters crv = pc.Dag( mc.curve( d = 1 , p = [ ( 0 , 0 , 0 ) , ( 0 , 0 , 0 ) ] ) ) clstr1 = pc.Dag( mc.cluster( '%s.cv[0]' % crv , wn = ( ctrl , ctrl ) )[ 0 ] ) clstr2 = pc.Dag( mc.cluster( '%s.cv[1]' % crv , wn = ( target , target ) )[ 0 ] ) mc.select( cl = True ) return crv , clstr1 , clstr2
def rebuild(self, overrides={}): ''' Rebuild the cluster deformer from the recorded deformerData @param overrides: Dictionary of data overrides to apply @type overrides: dict ''' # Apply Overrides self._data.update(overrides) # ========== # - Checks - # ========== # Check target geometry for obj in self._data['affectedGeometry']: if not mc.objExists(obj): raise Exception('Deformer affected object "' + obj + '" does not exist!') # ==================== # - Rebuild Deformer - # ==================== # Build Cluster Deformer and Handle if not mc.objExists(self._data['name']): # Create New Cluster cluster = mc.cluster(self.getMemberList(), n=self._data['name']) self._data['name'] = cluster[0] else: # Check Cluster if mc.objectType(self._data['name']) != 'cluster': raise Exception('Object "' + self._data['name'] + '" is not a valid cluster deformer!') # Rebuild Deformer result = super(ClusterData, self).rebuild(overrides) # Restore ClusterHandle Data if self._data['clusterHandle']: if not mc.objExists(self._data['clusterHandle']): raise Exception('Weighted Node "' + self._data['clusterHandle'] + '" does not exist!') try: mc.cluster(self._data['name'], edit=True, bindState=True, wn=(self._data['clusterHandle'], self._data['clusterHandle'])) except: pass # ================= # - Return Result - # ================= return result
def rebuild(self, overrides={}): """ Rebuild the cluster deformer from the recorded deformerData @param overrides: Dictionary of data overrides to apply @type overrides: dict """ # Apply Overrides self._data.update(overrides) # ========== # - Checks - # ========== # Check target geometry for obj in self._data["affectedGeometry"]: if not mc.objExists(obj): raise Exception('Deformer affected object "' + obj + '" does not exist!') # ==================== # - Rebuild Deformer - # ==================== # Build Cluster Deformer and Handle if not mc.objExists(self._data["name"]): # Create New Cluster cluster = mc.cluster(self.getMemberList(), n=self._data["name"]) self._data["name"] = cluster[0] else: # Check Cluster if mc.objectType(self._data["name"]) != "cluster": raise Exception('Object "' + self._data["name"] + '" is not a valid cluster deformer!') # Rebuild Deformer result = super(ClusterData, self).rebuild(overrides) # Restore ClusterHandle Data if self._data["clusterHandle"]: if not mc.objExists(self._data["clusterHandle"]): raise Exception('Weighted Node "' + self._data["clusterHandle"] + '" does not exist!') try: mc.cluster( self._data["name"], edit=True, bindState=True, wn=(self._data["clusterHandle"], self._data["clusterHandle"]), ) except: pass # ================= # - Return Result - # ================= return result
def displayLine(point1, point2, name='ctrlLine#', parent=str()): ''' Create a display line between two points Example: ..python displayLine('l_uparm_sc_jnt', 'l_uparm_pv_ctrl') #Return: 'ctrlLine1' displayLine('l_uparm_sc_jnt', 'l_uparm_pv_ctrl', name = 'l_uparm_pv_displayLine') #Return: 'l_uparm_pv_displayLine' :param point1: First node to connect display line to :type point1: str :param point2: Second node to connect display line to :type point2: str :return: Display line :rtype: str ''' #get posiitons of first and second points pnt1 = mc.xform(point1, q=True, ws=True, t=True) pnt2 = mc.xform(point2, q=True, ws=True, t=True) #create a pointList from point1 and point2 positions pointList = (pnt1, pnt2) #create display line from pointList displayLine = rigrepo.libs.curve.createCurveFromPoints(pointList, degree=1, name=name) #cluster the two ends of the dispay line to point1 and point2 mc.cluster('{}.cv[0]'.format(displayLine), wn=[point1, point1], bs=True, name='{}_1_{}'.format(displayLine, rigrepo.libs.common.CLUSTER)) mc.cluster('{}.cv[1]'.format(displayLine), wn=[point2, point2], bs=True, name='{}_2_{}'.format(displayLine, rigrepo.libs.common.CLUSTER)) #override display type of displayLine to be templated mc.setAttr('{}.overrideEnabled'.format(displayLine), 1) mc.setAttr('{}.overrideDisplayType'.format(displayLine), 2) mc.setAttr('{}.inheritsTransform'.format(displayLine), 0) if parent: mc.parent(displayLine, parent) return displayLine
def cvsToCLR(): type = '_CLR' i = 1 name = 'mid' cvs = cmd.filterExpand(ex = True, sm = 28) for one in cvs: cmd.select(one) cmd.cluster(name='%s%d%s'% (name, i, type)) cmd.group(name='%s%d%sGP'% (name, i, type)) i += 1
def make_ikspline_stretchy(*args): '''main function to make joints stretching''' try: #get data of IKfandle and joint selected_ikHandle = cmds.ls(sl=True)[0] ikJoints = cmds.ikHandle(selected_ikHandle, q=True, jl=True) numberOfBones = len(ikJoints) ikCurve = cmds.ikHandle(selected_ikHandle, q=True, c=True) cmds.rebuildCurve(ikCurve, rt=0, kr=0, d=4, s=1) curveInfo = cmds.arclen(ikCurve, ch=True) #create Node of length multiDivArclen = cmds.shadingNode('multiplyDivide', asUtility=True) cmds.setAttr(multiDivArclen + '.operation', 2) cmds.addAttr(multiDivArclen, ln="stretchy", at='double', dv=0, k=True) #connect curve length cmds.connectAttr(curveInfo + '.arcLength', multiDivArclen + '.input1X', f=True) cmds.connectAttr(multiDivArclen + '.outputX', multiDivArclen + '.stretchy', f=True) input2X = cmds.getAttr(multiDivArclen + '.input1X') cmds.setAttr(multiDivArclen + '.input2X', input2X) #multDivArclen.OutputX == 1 #create Node of thickness multiDivThickness = cmds.shadingNode('multiplyDivide', asUtility=True) cmds.setAttr(multiDivThickness + '.operation', 3) cmds.connectAttr(multiDivArclen + '.stretchy', multiDivThickness + '.input1X', f=True) cmds.setAttr(multiDivThickness + '.input2X', -0.5) #cmds.addAttr( multiDivArclen, ln="stretchy", at='double', dv=0, k=True) cmds.cluster(ikCurve + '.cv[3]', n="cluster_end") cmds.cluster(ikCurve + '.cv[0]', ikCurve + '.cv[1]', ikCurve + '.cv[2]', n="cluster_root") for i in range(numberOfBones): cmds.connectAttr(multiDivArclen + '.stretchy', ikJoints[i] + '.scaleX', f=True) if i > 0 and i < numberOfBones: cmds.connectAttr(multiDivThickness + '.outputX', ikJoints[i] + '.scaleY', f=True) cmds.connectAttr(multiDivThickness + '.outputX', ikJoints[i] + '.scaleZ', f=True) #cmds.connectAttr( outMultDiv+'.outputX', item+'.scaleX', f=True) except: print "no curve selected"
def crearLowCrvControl(curvesActual=None, cnt=True, rad=1): # curvesActual=cmds.ls(sl=1) for curveActual in curvesActual: newName = curveActual if '_' in curveActual: newName = curveActual.split(curveActual.split('_')[-1])[0] if curveActual: curve = cmds.duplicate(str(curveActual), name=newName + 'CRVLOW', rr=1)[0] '''if not cmds.getAttr(curve+'.minMaxValue')[0] == (0.0, 1.0):''' curve = cmds.rebuildCurve(curve, keepRange=0, ch=1, rpo=1, rt=0, end=0, kcp=0, kep=1, kt=0, s=3, d=3, tol=0.01)[0] #cmds.delete(curve, ch = 1) mel.eval( "wire -gw true -en 1.000000 -ce 0.000000 -li 0.000000 -dds 0 100 -name " + newName + 'WIRE' + " -w " + curve + " " + curveActual + ";") else: cmds.warning('colocar las curvas') if cnt: #creo cluster and rename that topCLR = cmds.cluster(str(curve) + '.cv[0:2]')[1] topCLR = cmds.rename(topCLR, newName + 'TOP_CLR') midCLR = cmds.cluster(str(curve) + '.cv[2:3]')[1] midCLR = cmds.rename(midCLR, newName + 'MID_CLR') endCLR = cmds.cluster(str(curve) + '.cv[3:5]')[1] endCLR = cmds.rename(endCLR, newName + 'BOT_CLR') #change pivot to start vertex p1 = cmds.xform(str(curve) + '.cv[0]', q=1, t=1, ws=1) cmds.xform(str(topCLR), piv=p1, ws=1) p2 = cmds.xform(str(curve) + '.cv[5]', q=1, t=1, ws=1) cmds.xform(str(endCLR), piv=p2, ws=1) CNTS = extraControl([topCLR, midCLR, endCLR], 'ZTR', 'TRF', 'CNT', radius=rad) return curve, topCLR, midCLR, endCLR
def pvLine(name, icon, joint): j = mel.eval('curve -d 1 -p 0 0 0 -p 1 0 0 -k 0 -k 1 ;') k = cmds.rename(name) c1 = cmds.cluster('%s.cv[0]' % k, n='%s_cluster' % k) c2 = cmds.cluster('%s.cv[1]' % k, n='%s_cluster' % k) cmds.parentConstraint(icon, c1, mo=0) cmds.parentConstraint(joint, c2, mo=0) i = cmds.group(k, c1, c2, n='%s_pad' % name) cmds.setAttr('%sHandle.visibility' % c1[0], 0) cmds.setAttr('%sHandle.visibility' % c2[0], 0) cmds.setAttr('%sShape.overrideDisplayType' % k, 2) cmds.setAttr('%sShape.overrideEnabled' % k, 1) return i
def pvLine(name, icon, joint): j=mel.eval('curve -d 1 -p 0 0 0 -p 1 0 0 -k 0 -k 1 ;') k=cmds.rename(name) c1=cmds.cluster('%s.cv[0]' % k, n='%s_cluster' % k) c2=cmds.cluster('%s.cv[1]' % k, n='%s_cluster' % k) cmds.parentConstraint(icon, c1, mo=0) cmds.parentConstraint(joint, c2, mo=0) i=cmds.group(k,c1,c2, n='%s_pad' % name) cmds.setAttr('%sHandle.visibility' % c1[0], 0) cmds.setAttr('%sHandle.visibility' % c2[0], 0) cmds.setAttr('%sShape.overrideDisplayType' % k, 2) cmds.setAttr('%sShape.overrideEnabled' % k, 1) return i
def gpsClusterPerFace(): selectionList = cmds.ls(selection=True) n = 0 if selectionList: while len(selectionList) > n: cmds.cluster(selectionList[n]) n += 1 else: cmds.warning("Please select objects or components!")
def on_btn_Mirror_clicked(self, args=None): if args == None: return geo = str(self.let_Geometry.text()) src = str(self.let_Source.text()) dst = str(self.let_Targent.text()) if not mc.objExists(geo): return if not mc.objExists(src): return if not mc.objExists(dst): return infoNode = mc.createNode('closestPointOnMesh') shape = mc.listRelatives(geo, s=True, path=True, type='mesh')[0] mc.connectAttr('%s.outMesh' % shape, '%s.inMesh' % infoNode) srcWeightListIndex = mc.listRelatives(mc.cluster(src, q=True, g=True), p=True, path=True).index(geo) dstWeightListIndex = mc.listRelatives(mc.cluster(dst, q=True, g=True), p=True, path=True).index(geo) vtxCounts = len(mc.ls('%s.vtx[*]' % geo, fl=True)) srcValues = mc.getAttr('%s.wl[%d].w[:%d]' % (src, srcWeightListIndex, vtxCounts - 1)) dstValues = [] self.progressBar.setMaximum(vtxCounts) for i, vtx in enumerate(mc.ls('%s.vtx[*]' % geo, fl=True)): postions = mc.xform(vtx, q=True, ws=True, t=True) mc.setAttr('%s.ipx' % infoNode, postions[0] * -1) mc.setAttr('%s.ipy' % infoNode, postions[1] * 1) mc.setAttr('%s.ipz' % infoNode, postions[2] * 1) dstValues.append(srcValues[mc.getAttr('%s.vt' % infoNode)]) #- self.progressBar.setValue(i) mc.setAttr( '%s.wl[%d].w[:%d]' % (dst, dstWeightListIndex, len(dstValues) - 1), *dstValues) mc.delete(infoNode) #- self.progressBar.setMaximum(1) self.progressBar.setValue(0)
def create_line(objects, attach=True, attachParents=[], name=""): """ Creates a line between objects, that optionally attaches to each """ if not name: name = "line_display" print("Attach is: {}".format(attach)) positions = get_positions(objects) curve = create_from_points(positions, name=name, degree=1) # Rig CVs to each object if attach: if not attachParents: attachParents = objects[:] print("Attaching...") cvs = get_cvs(curve) for i in range(len(objects)): cluster = cmds.cluster(cvs[i]) cmds.parentConstraint(objects[i], cluster, maintainOffset=True) return curve
def alignJawCtrl() : # Align jaw control to jaw joint. # Select jaw control curve then jaw joint. sels = mc.ls( sl = True ) ctrl = sels[0] jnt = sels[1] shp = mc.listRelatives( ctrl , shapes=True )[0] mc.select( shp , r=True ) fstCv = 14 scdCv = 2 fstPos = mc.xform( '%s.cv[%s]' % (shp,fstCv) , q=True , ws=True , t=True ) scdPos = mc.xform( '%s.cv[%s]' % (shp,scdCv) , q=True , ws=True , t=True ) midPos = [ (fstPos[0]+scdPos[0])/2 , (fstPos[1]+scdPos[1])/2 , (fstPos[2]+scdPos[2])/2 ] clstr = mc.cluster()[1] mc.select( clstr , r=True ) mc.move( midPos[0] , midPos[1] , midPos[2] , '%s.rotatePivot' % clstr ) mc.move( midPos[0] , midPos[1] , midPos[2] , '%s.scalePivot' % clstr ) mc.delete( mc.pointConstraint( jnt , clstr ) ) tipJnt = mc.listRelatives( jnt , type = 'joint' )[0] if tipJnt : mc.delete( mc.aimConstraint(tipJnt,clstr,aim=(0,0,1),u=(1,0,0),wut='vector',wu=(1,0,0)))
def createMasterCtrl(self, ctrl, offsetCtrl, curveShape, size, offsetScale): cmds.file(PATH + curveShape + ".ma", i=True, rdn =True) cmds.rename('control', ctrl) cmds.file(PATH + "circle.ma", i=True, rdn =True) cmds.rename('control', offsetCtrl) cmds.xform(offsetCtrl, scale=[offsetScale, offsetScale, offsetScale ]) cmds.makeIdentity(offsetCtrl, apply=True, s=True) cmds.parent(offsetCtrl, ctrl) cmds.addAttr(ctrl, at='bool', ln="offsetCtrl", dv=1) cmds.setAttr(ctrl + ".offsetCtrl", k=False, cb=True) offsetCtrlShapes = cmds.listRelatives(offsetCtrl, shapes=True) for offsetCtrlShape in offsetCtrlShapes: cmds.connectAttr(ctrl+".offsetCtrl", offsetCtrlShape+".visibility") cluster, clusterHandle = cmds.cluster(ctrl, name=ctrl+"_cluster") cmds.setAttr(clusterHandle + '.visibility', 0) cmds.setAttr(cluster + '.relative', 1) cmds.parent(clusterHandle, ctrl) cmds.addAttr(ctrl, at='double', ln="iconSize", minValue=0.1, dv=size, k=True) cmds.setAttr(ctrl + ".iconSize", k=False, cb=True) cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleX") cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleY") cmds.connectAttr(ctrl+".iconSize", clusterHandle+".scaleZ") cmds.setAttr(ctrl+".offsetCtrl", 0)
def createLine(_parents, _sceneData = False, _layer = False): nodes = [] lineCurve = "" firstTime = True for obj in _parents: pos = cmds.xform(obj, q=1, t=1, ws=1) if firstTime: lineCurve = cmds.curve(d=1, p=[pos]) nodes.append(lineCurve) cmds.setAttr(lineCurve+".overrideEnabled", 1) cmds.setAttr(lineCurve+".overrideDisplayType", 2) cmds.setAttr(lineCurve+".inheritsTransform", 0) firstTime = False else: cmds.curve(lineCurve, a=True, p=pos) #Clusters must be added after all the cvs are created. #Don't ask me why! for j in range(len(_parents)): clusterName = _parents[j]+"_CLUSTER" clusterPoint = cmds.cluster(lineCurve+".cv["+str(j)+"]", n=clusterName) nodes.append(clusterPoint[1]) #cmds.setAttr(clusterPoint[1]+".visibility", 0) cmds.parent(clusterPoint[1], _parents[j], a=1) if(_sceneData): addToLayer(_sceneData, "hidden", nodes) if _layer: addToLayer(_sceneData, _layer, lineCurve) return nodes
def use_weight_set(): cmds.select(cmds.cluster(cmds.textScrollList('UI_cluster_list', q=True, si=True)[0], q=True, g=True)[0]) mel.eval("ConvertSelectionToVertices;") weights = cmds.percent (cmds.textScrollList('UI_cluster_list', q=True, si=True)[0], q=True, v=True) cmds.filterExpand( ex=True, sm=31 ) elements = cmds.ls(sl=True, fl=True) return elements, weights
def controllerResize(self): number = float(self.ui.Do_Resize_DSB.text()) XYZ = ["X", "Y", "Z"] sel = cmds.ls(sl=True) for x in sel: curveName = x curveShape = cmds.listRelatives(curveName, s=True)[0] cvNum = cmds.getAttr('%s.spans' % curveShape) + cmds.getAttr( '%s.degree' % curveShape) conPivot = cmds.xform("%s" % curveName, q=True, ws=True, rp=True) cmds.select("%s.cv[0:%s]" % (curveName, cvNum)) cluster = cmds.cluster() cmds.move(conPivot[0], conPivot[1], conPivot[2], "%s.scalePivot" % cluster[1], "%s.rotatePivot" % cluster[1], absolute=True) if number > 0: for i in XYZ: cmds.setAttr("%s.scale%s" % (cluster[1], i), number) else: nagative_number = 1 - number * (-0.1) print nagative_number for i in XYZ: cmds.setAttr("%s.scale%s" % (cluster[1], i), nagative_number) cmds.DeleteHistory(cmds.select(sel))
def on_btn_Start_clicked(self, clicked=None): if clicked == None:return geometry = str(self.LET_Geometry.text()) joints = [jnt.strip() for jnt in str(self.LET_Skeleton.text()).split(',')] joints = [jnt for jnt in joints if mc.objExists(jnt)] self.progressBar_A.setMaximum(len(joints)) self.progressLabel_A.setText('0/%d'%len(joints)) for i, jnt in enumerate(joints): #- create cluster cluster = mc.cluster(geometry, rel=True) #- copy weights res = transSkinWeightsToCluster(geometry, geometry, jnt, cluster[0], self.progressBar_B, self.progressLabel_B) #if res: ##- weight Node #mc.cluster(cluster[0], e=True, wn=(jnt, jnt)) ##- delete handle #mc.delete(cluster[1]) #- progerss self.progressBar_A.setValue(i+1) self.progressLabel_A.setText('%d/%d'%(i+1, len(joints))) self.progressBar_A.setValue(0) self.progressBar_A.setMaximum(1) self.progressLabel_A.setText('0/0')
def offset_cache_static(self): checkSel = cmds.ls(sl=1) if len(checkSel)<2: print "you need to select two objects" leader = checkSel[1] cmds.select(leader, r=1) cmds.ConvertSelectionToVertices(leader) ld_lctr = self.locator_select_verts() follower = checkSel[0] cmds.select(follower, r=1) cmds.ConvertSelectionToVertices(follower) flw_lctr = self.locator_select_verts() # set the offset node for translate plsMns = cmds.shadingNode("plusMinusAverage", asUtility = 1) cmds.setAttr(plsMns+".operation", 2) cmds.connectAttr(ld_lctr+".translate", plsMns+".input3D[0]", f=1) cmds.connectAttr(flw_lctr+".translate", plsMns+".input3D[1]", f=1) # set cluster cmds.select(checkSel[0]) getpar=cmds.listRelatives(checkSel[0], p=1) getchildren=[(nodes) for nodes in cmds.listRelatives(getpar[0], ad=1, type="mesh") if "Orig" not in str(nodes) ] cmds.select(getchildren, add =1 ) create_cstr = cmds.cluster() # connect result to cluster cmds.connectAttr( plsMns+".output3D", create_cstr[0]+"Handle.translate", f = 1)
def on_btn_Start_clicked(self, clicked=None): if clicked == None: return geometry = str(self.LET_Geometry.text()) joints = [ jnt.strip() for jnt in str(self.LET_Skeleton.text()).split(',') ] joints = [jnt for jnt in joints if mc.objExists(jnt)] self.progressBar_A.setMaximum(len(joints)) self.progressLabel_A.setText('0/%d' % len(joints)) for i, jnt in enumerate(joints): #- create cluster cluster = mc.cluster(geometry, rel=True) #- copy weights res = transSkinWeightsToCluster(geometry, geometry, jnt, cluster[0], self.progressBar_B, self.progressLabel_B) #if res: ##- weight Node #mc.cluster(cluster[0], e=True, wn=(jnt, jnt)) ##- delete handle #mc.delete(cluster[1]) #- progerss self.progressBar_A.setValue(i + 1) self.progressLabel_A.setText('%d/%d' % (i + 1, len(joints))) self.progressBar_A.setValue(0) self.progressBar_A.setMaximum(1) self.progressLabel_A.setText('0/0')
def setup_blendshape_lattice(side = None, blendShape = None, divisions = [2,5,2], ldv = [2,2,2], parent = None): #--- this method setups the lattice deformer lat = cmds.lattice(blendShape, divisions = divisions, objectCentered = True, ldv = ldv) cmds.setAttr(lat[1] + '.v', 0) cmds.parent(lat, 'Shapes') points = cmds.ls(lat[1] + '.pt[*]', flatten = True) for point in range(len(points)): pos = cmds.xform(points[point], query = True, translation = True, worldSpace = True) cPoint = node.nControl(position = pos, color = 17, size = 1, shape = 1, side = side, description = "latPoint" + str(point), parent = parent, rotateOrder = 2) cmds.setAttr(cPoint.control['transform'] + '.v', lock = False) cmds.connectAttr('C_bedMid_CTL.latticeControls', cPoint.control['transform'] + '.v') cls = cmds.cluster(points[point], name = side + '_latCluster' + str(point) + '_CLS') for axis in 'xyz': cmds.connectAttr(cPoint.control['transform'] + '.t' + axis, cls[1] + '.t' + axis) cmds.parent(cls[1], 'Shapes') cmds.setAttr(cls[1] + '.v', 0)
def makeRefLine(self,stCtrl,edCtrl): self.ctrl = cmds.curve(d=1,p=[(0,0,0),(0,0,12)],k = [0,1], n = (self.name)) self.stCtrl = stCtrl self.edCtrl = edCtrl cmds.select(self.ctrl+'.cv[0]') stClu = cmds.cluster(n=(self.ctrl+'st_clu')) cmds.select(self.ctrl+'.cv[1]') edClu = cmds.cluster(n=(self.ctrl+'ed_clu')) km.ApplyConstrain(self.stCtrl,stClu).parentCon(0) km.ApplyConstrain(self.edCtrl,edClu).parentCon(0) cmds.setAttr(self.ctrl+'.overrideEnabled', 1) cmds.setAttr(self.ctrl+'.overrideDisplayType', 2) self.hkG = cmds.group(n = (stClu[1]+'_g'),em =1) dt.parentIT(stClu[1],self.hkG) dt.parentIT(edClu[1],self.hkG) return self.hkG
def copy_joint_weights_to_cluster(skin_mel_node, joint_mel_node): ''' ''' #- initlize api nodes skin_mfn_node = OpenMayaAnim.MFnSkinCluster(pymel.core.PyNode(skin_mel_node).__apiobject__()) joint_dag_path = OpenMaya.MDagPath(pymel.core.PyNode(joint_mel_node).__apiobject__()) #- get joint influcenced points and weight values components = OpenMaya.MSelectionList() weights = OpenMaya.MDoubleArray() skin_mfn_node.getPointsAffectedByInfluence(joint_dag_path, components, weights) #- create cluster component_strings = list() components.getSelectionStrings(component_strings) cluster_mel_node = mc.cluster(component_strings)[0] clus_mfn_node = OpenMayaAnim.MFnWeightGeometryFilter(pymel.core.PyNode(cluster_mel_node).__apiobject__()) #- get geometry's dagpath and component geo_dag_path = OpenMaya.MDagPath() geo_comp_obj = OpenMaya.MObject() components.getDagPath(0, geo_dag_path, geo_comp_obj) #- convert skinweights type to cluster weights type cluster_weights_array = OpenMaya.MFloatArray() for v in weights: cluster_weights_array.append(v) #- set weights clus_mfn_node.setWeight(geo_dag_path, geo_comp_obj, cluster_weights_array)
def softSelectionClusterWeights(*args): sel = mc.ls(sl=True, o=True) if not sel: raise RuntimeError('Please select some vertices.') weights = getSoftSelectionWeights() if not weights: raise RuntimeError('Please select some vertices.') #get manipulator position for pivot mc.setToolTo('Move') moveMode = mc.manipMoveContext('Move', query=True, mode=True) mc.manipMoveContext('Move', edit=True, mode=0) position = mc.manipMoveContext('Move', query=True, position=True) mc.manipMoveContext('Move', edit=True, mode=moveMode) clusterNode, clusterHandle = mc.cluster(sel[0]) for vert in mc.ls(sel[0]+'.vtx[*]', fl=True, l=True): weight = 0.0 if vert in weights.keys(): weight = weights[vert] mc.percent(clusterNode, vert, v=weight) #set cluster pivot mc.xform(clusterHandle, a=True, ws=True, piv=(position[0], position[1], position[2])) clusterShape = mc.listRelatives(clusterHandle, c=True, s=True) mc.setAttr(clusterShape[0] + '.origin', position[0], position[1], position[2])
def _createPerEye(self, side, geos ): mc.select( geos ) clu = mn.Node( mc.cluster( n = side + '_Eye_CLU' )[1] ) print clu.name mc.select( geos ) lat = mn.Nodes( mc.lattice( n = side + '_Eye_LAT', objectCentered = True ) ) ctl = crv.Curve( side + '_Eye_ctl' ) ctl.create( 'circleZ' ) print ctl.name par = mn.Node( mc.parentConstraint( clu, ctl, mo = False )[0]) par.delete() ctl.a.tz.v = self.distance_control_sb.value() + ctl.a.tz.v mc.makeIdentity( ctl, a = True, t = 1, r = 1, s = 1 ) loc = mn.createNode( 'locator' ).parent loc.name = side + '_Eye_Top_Loc' par = mn.Node( mc.aimConstraint( ctl, clu, mo = True, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=loc )[0]) trf = mn.createNode( 'transform' ) trf.name = side + '_Eye_Def_grp' lat[1].parent = trf lat[2].parent = trf clu.parent = trf loc.parent = trf return trf, ctl
def createIKCtrlsOnJnts(ikCrv, parentCtrl, size=1): ikCVNum = ll.getCurveCVCount(ikCrv) prev = parentCtrl for i in range(1, ikCVNum): clus = mc.cluster('%s.cv[%d]' % (ikCrv, i), n=parentCtrl.replace('masterctrl', 'ikClus%d') % i) cvPos = mc.xform('%s.cv[%d]' % (ikCrv, i), q=1, ws=1, t=1) mc.select(parentCtrl) meval('wireShape("plus")') ikCtrl = mc.rename(masterCtrl.replace('masterctrl', 'ikCtrl%d' % i)) mc.xform(ikCtrl, t=cvPos, ws=1) mc.scale(size, size, size, ikCtrl, ocp=1) mc.makeIdentity(ikCtrl, a=1, s=1) mc.parent(ikCtrl, parentCtrl) lsZeroOut(ikCtrl) ctrlPR = lsZeroOut(ikCtrl, 'PR') mc.addAttr(ikCtrl, ln='SPACE', at='bool', k=1) mc.setAttr(ikCtrl + '.SPACE', l=1) mc.addAttr(ikCtrl, ln='parent', at='float', dv=0, min=0, max=1, k=1) mc.addAttr(ikCtrl, ln='master', at='float', dv=1, min=0, max=1, k=1) mc.addAttr(ikCtrl, ln='world', at='float', dv=0, min=0, max=1, k=1) mc.parentConstraint(ikCtrl, clus) cons = mc.parentConstraint(prev, parentCtrl, ctrlPR, mo=1)[0] wal = mc.parentConstraint(cons, q=1, wal=1) if len(wal) > 1: mc.connectAttr(ikCtrl + '.parent', '%s.%s' % (cons, wal[0]), f=1) mc.connectAttr(ikCtrl + '.master', '%s.%s' % (cons, wal[1]), f=1) prev = ikCtrl
def cluster_on_curve(self, crv): """Creates a cluster on each cv on the given curve. @param crv: the curve @type crv: String @return: a list of all clusters """ clsName = str(crv)[:-4] degree = cmds.getAttr(crv+".degree") spans = cmds.getAttr(crv + ".spans") cvs = degree + spans clsReturn = list() for i in range(0, cvs): cmds.select(crv + ".cv[" + str(i) +"]", r=True) cls = cmds.cluster(en=1) grp = "" if i==0: cmds.rename(cls[1],(clsName + "Root" + "_" + 'CLS')) grp = cmds.group(n=(clsName + "Root" + "_" + 'CLS' + "_" + 'GRP')) elif i==(cvs-1): cmds.rename(cls[1],(clsName + "End" + "_" + 'CLS')) grp = cmds.group(n=(clsName + "End" + "_" + 'CLS' + "_" + 'GRP')) else: cmds.rename(cls[1],(clsName + str(i) + "_" + 'CLS')) grp = cmds.group(n=(clsName + str(i) + "_" + 'CLS' + "_" + 'GRP')) # END if #clsAr[i] = grp clsReturn.append(grp) cmds.setAttr(grp + ".visibility", 0) # END for return clsReturn
def createTemplate(self , eyeMesh): # create eye jnt eyeJnt=[] if 'L_' in str(eyeMesh): helpClu = mc.cluster(eyeMesh)[0] LeyeJnt = mc.joint(p=(0,0,0),name=eyeMesh+'_skin_jnt') self.fromAtoB(eyeJnt,helpClu,1) ReyeJnt = mc.mirrorJoint(mirrorYZ=True,mirrorBehavior=False,searchReplace=('L_', 'R_') eyeJnt.append(LeyeJnt) eyeJnt.append(ReyeJnt) else: self.mayaError('Please select the left eye.') return eyeJnt def createEyeRig(self): if mc.objExists(self.eyeGlobalCtrl) == False: EyesGlobalCtrl = mc.curve(d=1,p=[(-1.069806, 1.027703, 0),(-1.651954,1.89895,0),(-2.523201,2.481098,0),(-3.550904,2.68552,0),(-4.578607,2.481098,0),(-5.449854,1.89895,0),(-6.032002,1.027703,0),(-6.236424,0,0),(-6.032002,-1.027703,0),(-5.449854 ,-1.89895, 0),(-4.578607,-2.481098,0), (-3.550904,-2.68552,0),(-2.523201, -2.481098, 0),(-1.651954,-1.89895,0),(-1.069806,-1.027703,0),(1.058138,-1.032345,0),(1.642915, -1.907527,0),(2.518098,-2.492305,0),( 3.550443,-2.69765,0),(4.582788,-2.492305,0),(5.45797,-1.907527,0),( 6.042748,-1.032345,0),(6.248093,0,0),(6.042748,1.032345,0),( 5.45797,1.907527,0 ),(4.582788,2.492305,0),( 3.550443,2.69765,0),(2.518098,2.492305,0 ),(1.642915,1.907527,0),(1.058138,1.032345,0),( -1.069806,1.027703,0)],k=[0,1,2,3,4,5,6,7,8,9,10,11,12 ,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30],n=self.eyeGlobalCtrl) L_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='L_'+self.eyeAimCtrl) R_EyeAimCtrl = mc.curve(d=1,p=[(3.653116 ,0.946994,0), (3.653116 ,0 ,0),( 2.706122, 0, 0) , (3.653116 ,0, 0),(4.600109, 0 ,0) , (3.653116 ,0, 0) , (3.653116 ,-0.946994, 0) ],k=[0, 1, 2 ,3 ,4 ,5 , 6 ],n='R_'+self.eyeAimCtrl) mc.parent(L_EyeAimCtrl , EyesGlobalCtrl) mc.parent(R_EyeAimCtrl , EyesGlobalCtrl) self.fastGrp('On' , ['zero','con','sdk'],L_EyeAimCtrl) self.fastGrp'On' , ['zero','con','sdk'],R_EyeAimCtrl) zeroGrp = self.fastGrp('On' , ['zero','con','sdk'],EyesGlobalCtrl)[2]
def createIKCtrlsOnJnts(ikCrv, parentCtrl, size=1): ikCVNum = ll.getCurveCVCount(ikCrv) prev=parentCtrl for i in range(1, ikCVNum): clus = mc.cluster('%s.cv[%d]'%(ikCrv, i), n=parentCtrl.replace('masterctrl','ikClus%d')%i) cvPos = mc.xform('%s.cv[%d]'%(ikCrv, i), q=1, ws=1, t=1) mc.select(parentCtrl) meval('wireShape("plus")') ikCtrl = mc.rename(masterCtrl.replace('masterctrl','ikCtrl%d'%i)) mc.xform(ikCtrl, t=cvPos, ws=1) mc.scale(size, size, size, ikCtrl, ocp=1) mc.makeIdentity(ikCtrl, a=1, s=1) mc.parent(ikCtrl, parentCtrl) lsZeroOut(ikCtrl) ctrlPR = lsZeroOut(ikCtrl, 'PR') mc.addAttr(ikCtrl, ln='SPACE', at='bool', k=1) mc.setAttr(ikCtrl+'.SPACE', l=1) mc.addAttr(ikCtrl, ln='parent', at='float', dv=0, min=0, max=1, k=1) mc.addAttr(ikCtrl, ln='master', at='float', dv=1, min=0, max=1, k=1) mc.addAttr(ikCtrl, ln='world', at='float', dv=0, min=0, max=1, k=1) mc.parentConstraint(ikCtrl, clus) cons = mc.parentConstraint(prev, parentCtrl, ctrlPR, mo=1)[0] wal = mc.parentConstraint(cons, q=1, wal=1) if len(wal) > 1: mc.connectAttr(ikCtrl+'.parent', '%s.%s'%(cons, wal[0]), f=1) mc.connectAttr(ikCtrl+'.master', '%s.%s'%(cons, wal[1]), f=1) prev=ikCtrl
def createClusterFromSelection(*args): vtx = cmds.ls(sl=True, fl=True) for v in vtx: cmds.select(cl=True) clu = cmds.cluster() pos = cmds.xform(v, q=True, ws=True, t=True) cmds.xform(clu, ws=True, t=pos)
def clusterCurve(splineCurve): clusters = [] clusterCtrls = [] # Get all CVs in spline curve curveCVs = cmds.ls('%s.cv[:]' % splineCurve, flatten=1) for i, cv in enumerate(curveCVs): # Create cluster for each CV cvCluster = cmds.cluster(cv, name='spl_%s_CL' % i) cvCluster = cvCluster[1] # cmds.cluster() returns [cluster, handle] clusters.append(cvCluster) if i > 0: # Create control for cluster cvPos = cmds.pointPosition(cv) cvControl = createCubeControl('spl_%s_CTRL' % i, cvPos) cmds.makeIdentity(cvControl, apply=1, t=1, r=1, s=1, n=0) cmds.parentConstraint(cvControl, cvCluster, maintainOffset=1) clusterCtrls.append(cvControl) return clusters, clusterCtrls
def makePipeJoints(): #track selection order must be on for this to work joints = [] sel = cmd.ls(os=True) obj = cmd.ls(sl=True, o=True) name = obj[0].rsplit('_', 1)[0] for one in sel: strip = re.search(r"\[([0-9]+)\]", one) num = strip.group(1) cmd.select(one) cmd.polySelect(el=int(num)) clust = cmd.cluster(n = 'poo#') posi = cmd.getAttr(clust[0]+'HandleShape.origin') cmd.delete (clust[0]) size = len(joints) joints.append(cmd.joint(n='%s_%s_JNT' %(name, size+1),p = posi[0])) if size > 0: cmd.parent(joints[size], joints[size-1]) cmd.joint(joints[size-1], e=True, oj = 'xyz', sao = 'yup') circle = cmd.circle(nr = [1, 0, 0], n='%s_%s_CTL' %(name, size)) group = cmd.group(n = '%s_GP' %(circle[0])) jntCTL(joints[size-1], circle[0], group) if size > 1: cmd.parentConstraint(joints[size-2], group, mo =1) cmd.select(joints, obj[0]) cmd.skinCluster(mi=4)
def main(): mm.eval('selectCurveCV("all");') sel = mc.ls(sl=1, fl=1) grpname = (sel[0].split('.')) grpname = grpname[0]+"_grp" grp = mc.group(em=1, n=grpname) for i in sel: iname = i.replace('[', '') iname = iname.replace(']','') iname = iname.replace('.','_') locname = iname+"_loc" clusname = iname+"_clus" mc.select(i, r=1) print "here" cluster = mc.cluster(n=clusname) location = mc.xform(cluster, q=1, ws=1, sp=1) print location locator = mc.spaceLocator(n=locname, p=(location[0], location[1], location[2])) mc.xform(locator, cp=1) set_vis = clusname+"Handle.visibility" mc.setAttr(set_vis, 0) mc.parent(cluster, locator) mc.parent(locator, grp) shape = mc.listRelatives(locator) mc.setAttr((shape[0]+".overrideEnabled"),1) mc.setAttr((shape[0]+".overrideColor"),17)
def controlShape(self): name = self._name + self._suffix if self._style == "cube": shape = utils.controlShapes.cube() if self._style == "sphere": shape = utils.controlShapes.sphere() if self._style == "spine": shape = utils.controlShapes.spine() orient = (0,0,0) if self._orient == (1,0,0): orient = (90,0,0) if self._orient == (0,1,0): orient = (0,90,0) if self._orient == (0,0,1): orient = (0,0,90) control = "cube_ctrl" control = mc.rename(shape, name) # move control cluster = mc.cluster(control) mc.xform(cluster, t=self._center, s=self._size, ro=orient) mc.delete(control, ch=True) mc.setAttr(control + ".overrideEnabled", 1) # scale control mc.xform(control, scale=self._size) mc.makeIdentity(control, apply=True, s=1) self.controller = control self.controlShape = mc.listRelatives(control, shapes=True)[0]
def setClusterWeights(geometry, args, weights): weightListIndex = mc.listRelatives(mc.cluster(args, q=True, g=True), p=True, path=True).index(geometry) vtxCounts = len(weights) weights = mc.setAttr( '%s.wl[%d].w[:%d]' % (args, weightListIndex, vtxCounts - 1), *weights)
def Fivecrv(): GlobalName = 'tmp' basecurve5 = cmds.rename( mel.eval( "curve -d 3 -p -4 0 0 -p -2 0 0 -p 0 0 0 -p 2 0 0 -p 4 0 0 -k 0 -k 0 -k 0 -k 1 -k 2 -k 2 -k 2 ;" ), (GlobalName + '_Wire')) curve5Size = 5 curveOption = basecurve5 curveOptionFinal.append(curveOption) curveSize = curve5Size for i in range(curveSize): cls = cmds.cluster(str(curveOption) + '.cv[' + str(i) + ']', n=(GlobalName + 'CrvCls_0' + str(i))) clusterList.append(cls[1]) for i in clusterList: tmpctrls = cmds.circle(n=(i + '_Ctrl'), nr=[1, 0, 0], ch=0) cmds.delete(cmds.pointConstraint(i, tmpctrls)) cmds.makeIdentity(tmpctrls, apply=True, t=1, r=1, s=1) cmds.pointConstraint(tmpctrls, i, mo=True) ctrlList.append(tmpctrls[0]) clGrp = cmds.group(clusterList, n=('Cl_Group' + GlobalName)) ctrlGrp = cmds.group(ctrlList, n=('Ctrl_Group' + GlobalName)) mainGrp = cmds.group(clGrp, ctrlGrp, curveOption, n=('Main_' + GlobalName + '_Grp')) return ctrlList
def create_cluster(self, mesh): cluster = cmds.cluster()[0] cluster_handle_dag = oopmaya.DAG_Node() cmds.setAttr("{0}.relative".format(cluster), 1) cmds.parent(cluster_handle_dag.name(), mesh)
def softModToCluster(): softTransform = rig.ls(sl = True)[0] solftMod = rig.listConnections(softTransform,s = False,d = True,type = 'softMod')[0] modifModel = rig.listConnections(solftMod,s = False,d = True,type = 'mesh') if modifModel: origPos = rig.xform(softTransform,q = True,t = True,wd = True) for mesh in modifModel: prePos = [] curPos = [] weights = [] vtxs = rig.ls(mesh+'.vtx[*]',fl = True) rig.xform(softTransform,t = (0,0,0),wd = True) for vtx in vtxs: pos = rig.xform(vtx,q = True,t = True,wd = True) prePos.append(pos) rig.xform(softTransform,t = (0,1,0),wd = True) for vtx in vtxs: pos = rig.xform(vtx,q = True,t = True,wd = True) curPos.append(pos) weights = [math.pow(math.pow(pos[0]-curPos[i][0],2)+math.pow(pos[1]-curPos[i][1],2)+math.pow(pos[2]-curPos[i][2],2),0.5) for i,pos in enumerate(prePos)] rig.xform(softTransform,t = (0,0,0),wd = True) CLS = rig.cluster(mesh,n = mesh+'_CLS') for i,vtx in enumerate(vtxs): rig.percent(CLS[0],vtx,v = weights[i]) rig.xform(softTransform,t = origPos,wd = True)
def createCluster( clusterName, objs, **kwargs): """ Creates cluster on object / objects """ cluster = (cmds.cluster(objs, name = (clusterName + "_CLS"), **kwargs))[1] clusterGrp = cmds.group(cluster, name = (clusterName + "_GRP") ) return [cluster,clusterGrp]
def cluster_on_curve(cu): # find number of CVs in curve numCVs = cmds.getAttr('%s.controlPoints' % cu, size=1) res = [] # make CV into a cluster for i in range(numCVs): cl = cmds.cluster('%s.cv[%s]' % (cu, i), relative=False, n='vk_cluster#')[1] res.append(cl) return res
def ctrlTocv(self ,ctrlList,spanCrv): #--------------------------------------------------------------------------------------# #note : control the curve points. #--------------------------------------------------------------------------------------# crvPointNum = len(mc.ls(spanCrv+'.cv[:]' , fl=1)) for i in range(crvPointNum): clu = mc.cluster(spanCrv + '.cv[' + str(i) + ']',n = ctrlList[i] + '_clu')[1] mc.setAttr(clu + '.visibility',0) mc.parent(clu,ctrlList[i])