def createBlendshape(source, blendshape, AllP0, AllPDef): #------------MOTION VECTOR TRANSFER-------------# # create array of all vertices of the blendshape cmds.move(0,0,0, blendshape) cmds.select(clear=True) cmds.select(blendshape+".vtx[*]") AllPBlend = cmds.ls(sl=1, fl=True) #vertex list original source mesh O = getVtxPos( source ) #vertex list source mesh blendshape B = getVtxPos( blendshape ) # matrix of motion vectors from source to blendshape vertex positions MV = numpy.matrix(B)-numpy.matrix(O) MV = numpy.asmatrix(MV) ''' # rotating and scaling of motion vectors using these functions gives wrong results # and is not deforming the motion vectors like it should. # I have not been able to debug this in the given time and have therefore taken these parts out for the moment. # Simply using the motion vectors on the deformed source mesh results in acceptable blend shapes #-------------------------ROTATION-----------------------------# N0 = normalMatrix(AllP0) # normal matrix for source N1 = normalMatrix(AllPDef) # normal matrix for deformed source #------------ # list of motion vector rotations R = [] # find local source vertex coordinate systems before deformation, then after deformation for i in range(0, len(P0)): localOrig = findLocal(AllP0[i], N0[i]) localDef = findLocal(AllPDef[i], N1[i]) ODR = findRotationMatrix(localOrig, localDef) R.append(ODR) R = numpy.asarray(R) #--------------------------MAGNITUDE---------------------------# S = [] for i in AllP0: S.append(findScaleMatrix(i, AllP0, P0, R)) S = numpy.asarray(S) #--------OVERALL MOTION VECTOR ROTATION AND MAGNITUDE ADJUSTMENT--------# ''' # duplicate deformed source to make blendshape blendName = "target" + blendshape cmds.duplicate("sourceDeformed", n = blendName) cmds.select(clear=True) cmds.select(blendName+".vtx[*]") defBlend = cmds.ls(sl=1, fl=True) for i in range(0,len(AllP0)): cmds.move(float(MV[i, 0]), float(MV[i, 1]), float(MV[i, 2]), defBlend[i], r=True) '''
def _setup_wire_deformer(self, mesh, wire, wirebase, curve, parent, complexity): """Setup the wire deformer. If complexity is 1 or higher call this function recursively to create a wire deformer on the nurbs surface. @param mesh(string): PolyMesh used to wire deform @param wire(string): Descriptive part of the name of the wire deformer @param wirebase(string): Descriptive part of the name of the base wire @param curve(string): Curve used for wireTool deformer @param parent(string): Parent node of the wire setup @param complexity(uint): complexity level value """ w = wire wb = wirebase cmds.wire(mesh, w=curve, dds=[0, 10000], n=w, foc=False) cmds.rename(cmds.listConnections('%s.baseWire[0]' % w)[0], wb) if not cmds.listRelatives(curve, p=True) == [self.wire_grp]: cmds.parent(curve, wb, self.wire_grp) # end if wbs = cmds.listRelatives(wb, ad=True, type='shape')[0] cs = cmds.listRelatives(curve, ad=True, type='shape')[0] cmds.setAttr('%s.rotation' % w, 0) # connect to showHistory cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % w) cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % wb) cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % wbs) cmds.connectAttr('%s.showHistory' % self.mod_grp, '%s.ihi' % cs) if complexity: cmds.duplicate(self.curve, n=self.nrbcurve) return self._setup_wire_deformer(self.surface, self.nrbwire, self.nrbwirebase, self.nrbcurve, self.parent, 0)
def __setup_final_meshes(self): #--- this method setups the final meshes if 'FINAL' in self.mesh: if cmds.objExists(self.mesh): self.final_mesh = self.mesh else: self.final_mesh = cmds.duplicate(self.mesh) cmds.parent(self.final_mesh, self.sf_final_meshes) final_name = cmds.rename(self.final_mesh, self.mesh) self.final_mesh = final_name else: if cmds.objExists(self.mesh + 'FINAL'): self.final_mesh = self.mesh + 'FINAL' else: self.final_mesh = cmds.duplicate(self.mesh) cmds.parent(self.final_mesh, self.sf_final_meshes) final_name = cmds.rename(self.final_mesh, self.mesh + 'FINAL') self.final_mesh = final_name if cmds.objExists(self.mesh + '_BSP'): #--- setup blendShape deformer self.final_bsp = self.mesh + '_BSP' cmds.setAttr(self.final_bsp + '.' + self.mesh, 1) cmds.setAttr(self.mesh + '.v', 0) else: if 'FINAL' in self.mesh: self.mesh = self.mesh.split('FINAL')[0] self.final_bsp = cmds.blendShape(self.mesh, self.final_mesh, name = self.mesh + '_BSP')[0] cmds.setAttr(self.final_bsp + '.' + self.mesh, 1) cmds.setAttr(self.mesh + '.v', 0)
def bdRigEye(side): #create IK handles for the bind joints, for now getting the joints based on the name bindJoints = cmds.ls(side + "*Lid_jnt_*") eyeJoint = cmds.ls(side + "*eye*jnt")[0] eyeAnim = cmds.ls(side + '_eye_anim') cmds.aimConstraint(eyeAnim[0],eyeJoint,offset = [0, 0, 0] ,weight=1 , aimVector =[1 ,0 ,0] ,upVector=[0, 1, 0] ,worldUpType="vector" ,worldUpVector= [0,1,0]) blinkUpJnt = cmds.duplicate(eyeJoint,name = side + '_eye_upLid_blink_jnt',po=True) blinkLowJnt = cmds.duplicate(eyeJoint,name = side + '_eye_lowLid_blink_jnt',po=True) baseLidsJnt = cmds.ls(side + '*lids*base') cmds.parent([blinkUpJnt[0],blinkLowJnt[0]],baseLidsJnt[0]) for joint in bindJoints: print joint endJoint = cmds.listRelatives(joint,c=True,type='joint') ikName = endJoint[0].replace('bnd_jnt','ikHandle') ctrlName = endJoint[0].replace('bnd_jnt','anim') bdRigUtils.bdAddIk(joint,endJoint[0],'ikSCsolver',ikName) bdRigUtils.bdBuildBoxController(endJoint[0],ctrlName,0.2) bdRigUtils.bdAddAttributeMinMax(ctrlName,['BlinkPosition'],'double',-5,5,1) cmds.parent(ikName,ctrlName) bdBuildJointStructure(joint,ctrlName,ikName) allAnimsGrps = cmds.ls(side + '*eye*CON_??',type='transform') globalAnimGrp = cmds.ls('controllers') cmds.parent(allAnimsGrps,globalAnimGrp[0]) bdAddEyeAttr(eyeAnim[0]) bdCreateVerticalFollow(side) bdCreateSideFollow(side) bdCreateBlink(side)
def triangulateMesh(isObj, simplify, smoothe): if isObj and not cmds.objExists('triObj'): cmds.select(baseObject) cmds.duplicate(baseObject, name = "triObj") cmds.select('triObj') if smoothe: cmds.polySmooth('triObj', c=smoothe) cmds.polyReduce(ver = 1) cmds.polyReduce(ver = 1) if simplify > 0: cmds.polyReduce(ver = 1, p = simplify) num_faces = cmds.polyEvaluate('triObj', f=True) print "Triangulating faces..." #iterate over faces face_i = 0 while face_i < num_faces: if ((num_faces - face_i) % 5 == 0): print "Triangulate check: Approximately " + str(num_faces - face_i) + " faces remaining...." face = cmds.select('triObj.f['+ str(face_i)+']') verts = getCorners(isObj,face_i) if not isCoplanar(verts): cmds.polyTriangulate('triObj.f['+ str(face_i)+']') num_faces = cmds.polyEvaluate('triObj', f=True) face_i +=1
def symmetry(): #getting nodes sel = cmds.ls(selection=True) if len(sel) == 1: cmds.warning('Select the edited mesh first, then the original mesh last!') return if len(sel) > 2: cmds.warning('Select the edited mesh first, then the original mesh last!') return edit = sel[0] original = sel[1] #creating symmetry mesh mirror = mirrorBlendshape([edit], original)[0] copy = cmds.duplicate(original)[0] bldShp = cmds.blendShape(edit, mirror, copy)[0] cmds.setAttr('%s.%s' % (bldShp, edit), 1) cmds.setAttr('%s.%s' % (bldShp, mirror), 1) symmetry = cmds.duplicate(copy)[0] symmetry = cmds.rename(symmetry, edit + '_symmetry') cmds.delete(copy, mirror) return symmetry
def prepare(self): """ preparing mirror corretiveShape """ # default pose self.setDefaultPose() meshName = (name.getSide(self.mesh)+ "_" + name.getDescription(self.mesh) + "DUP" + "_" + name.getType(self.mesh)) #make hierachy if not cmds.objExists(meshName): dup = cmds.duplicate(self.mesh, rr=True, n=meshName) attribute.lockAll(dup[0], True) cmds.setAttr(dup[0] + ".visibility", 0) cmds.parent(dup, self.DupsName) self.wrapDeformer(dup, self.mesh) xform.zeroOut(dup[0], t = 1, r = 1, s = 1) self.dups.append(dup) #END if else: dup = meshName print "%s already exists!!!" % meshName #END else #pose copy eachPoseName = (name.getSide(self.mesh)+ "_" + name.getDescription(self.mesh) + self.description + "_" + name.getType(self.mesh)) cmds.setAttr(self.control + ".rotate" + self.axis, self.angle) self.eachPose = cmds.duplicate(dup, rr=True, n=eachPoseName) cmds.parent(self.eachPose, self.TransName) xform.zeroOut(self.eachPose[0], t = 1, r = 1, s = 1) #neutral pose. self.setDefaultPose()
def insertDots(self): # copy dot object # copy cutout object # run mesh difference # delete the layers # delete the groups # rename the cutout. for dot in self.dots: # Copy sphere object from the template object. newDot = cmds.duplicate(self.getTemplateObjectName(dot.templateName()))[0] for cutout in dot.cutouts: # Copy cutout object from the template object, and rotate it. newCutout = cmds.duplicate(self.getTemplateObjectName(cutout.shape))[0] cutoutDagPath = self.getDagPathFromPath(newCutout) mfnTransform = OpenMaya.MFnTransform(cutoutDagPath) mfnTransform.rotateBy(cutout.rotation, OpenMaya.MSpace.kTransform) # Mesh boolean combine, with 'difference' operator. boolOp = cmds.polyBoolOp(newDot, newCutout, op=2) # Update the dot copy name and remove history. newDot = boolOp[0] cmds.delete(newDot, constructionHistory=True) dotPath = "dot_{0}".format(dot.name()) cmds.rename(newDot, dotPath) # Move the new dot onto the final grid for printing. self.positionDot(dotPath, dot.vertexId)
def makeRobot(): MayaCmds.polyCube(name="head") MayaCmds.move(0, 4, 0, r=1) MayaCmds.polyCube(name="chest") MayaCmds.scale(2, 2.5, 1) MayaCmds.move(0, 2, 0, r=1) MayaCmds.polyCube(name="leftArm") MayaCmds.move(0, 3, 0, r=1) MayaCmds.scale(2, 0.5, 1, r=1) MayaCmds.duplicate(name="rightArm") MayaCmds.select("leftArm") MayaCmds.move(1.25, 0, 0, r=1) MayaCmds.rotate(0, 0, 32, r=1, os=1) MayaCmds.select("rightArm") MayaCmds.move(-1.25, 0, 0, r=1) MayaCmds.rotate(0, 0, -32, r=1, os=1) MayaCmds.select("rightArm", "leftArm", "chest", r=1) MayaCmds.group(name="body") MayaCmds.polyCube(name="bottom") MayaCmds.scale(2, 0.5, 1) MayaCmds.move(0, 0.5, 0, r=1) MayaCmds.polyCube(name="leftLeg") MayaCmds.scale(0.65, 2.8, 1, r=1) MayaCmds.move(-0.5, -1, 0, r=1) MayaCmds.duplicate(name="rightLeg") MayaCmds.move(1, 0, 0, r=1) MayaCmds.select("rightLeg", "leftLeg", "bottom", r=1) MayaCmds.group(name="lower") MayaCmds.select("head", "body", "lower", r=1) MayaCmds.group(name="robot")
def prepare(setname="cache_set", groupname="cache_group", prefix="cache_"): selection = cmds.ls(sl=True, l=True) if len(selection) == 0: cmds.warning("Please select objects!") return cmds.duplicate() dup = cmds.ls(sl=True, l=True) if cmds.objExists(groupname): cmds.parent(dup, groupname) else: cmds.group(w=True, n=groupname) cmds.select(groupname) dup = get_shapes() add_to_set_of_shapes(setname, dup) i = 0 for obj in dup: cmds.blendShape([selection[i], obj], w=(0, 1),o="world", foc=True) objects = [] objects.append(obj) addattr(objects, prefix+str(i)) i=i+1
def duplicate_button( self, *args ): self.original_selected_objects = cmds.ls( selection=True ) if( len(self.original_selected_objects) == 0 ): print "Nothing selected" return 0 elif( len(self.original_selected_objects) == 1 ): self.relatives = cmds.listRelatives( children=True ) if( len(self.relatives) == 1 ): print "Skip combine" cmds.duplicate( self.original_selected_objects, name=self.original_selected_objects[0] + "_Copy" ) cmds.delete( constructionHistory=True ) the_parent = cmds.listRelatives( parent=True ) if( the_parent != None ): cmds.parent( self.original_selected_objects[0] + "_Copy", world=True ) else: self.combine() else: self.combine() self.newOriginCopy = cmds.ls( selection=True )[0] self.bbox = cmds.exactWorldBoundingBox( self.newOriginCopy ) cmds.move((self.bbox[0] + self.bbox[3])/2, self.bbox[1], (self.bbox[2] + self.bbox[5])/2, self.newOriginCopy + ".scalePivot", self.newOriginCopy + ".rotatePivot", absolute=True) cmds.move( 0, 0, 0, self.newOriginCopy, rpr=True ) cmds.makeIdentity( apply=True, t=1, r=1, s=1 ) cmds.delete( constructionHistory=True )
def geoCrowd() : # Import referenced characters # select geometries then run script sels = mc.ls( sl=True ) ctrls = [] for sel in sels : ns = sel.split( ':' )[0] if not ns in ctrls : ctrl = mc.circle( nr=(0,1,0) , ch=False )[0] grp = mc.group( ctrl ) root = '%s:Root_Ctrl' % ns mc.delete( mc.parentConstraint( root , grp ) ) ctrl = mc.rename( ctrl , ns ) mc.rename( grp , '%s_grp' % ns ) ctrls.append( ns ) attrs = ('tx','ty','tz','rx','ry','rz','sx','sy','sz') for attr in attrs : if mc.getAttr( '%s.%s' % ( sel , attr ) , l=True ) : mc.setAttr( '%s.%s' % ( sel , attr ) , l=False ) mc.select( sel , r=True ) mc.duplicate( sel , rr=True ) geo = mc.ls( sl=True , l=True )[0] mc.parent( geo , ctrl )
def CreateCamera(self): print "Creating camera" #Array to store all objects in the scene cmds.select(None) #Copy from the current active camera cmds.duplicate( self.GetActiveCamera(), name = self.Camera) try:cmds.delete(self.Camera + "|CMForegroundPlane") except:pass try:cmds.delete(self.Camera + "|CMBackgroundPlane") except:pass i = 0 while(cmds.objExists("shot_" + str(i))): try:cmds.delete(self.Camera + "|" + "shot_" + str(i) + "_ImagePlane") except:pass i = i + 1 #Make the camera startup so that the user may not delete it directly #Enable the resolution gate cmds.camera(self.Camera, edit = True, startupCamera = True, displayResolution = True) #Make the camera hidden cmds.setAttr(self.Camera + ".visibility", False) #Add the attributes to define range and renderability cmds.select(self.Camera) cmds.addAttr(longName = 'CMRenderable', attributeType = 'bool', defaultValue = True) cmds.addAttr(longName = 'StartRange', attributeType = 'short', defaultValue = 0, min = 0, max = 35) cmds.addAttr(longName = 'StopRange' , attributeType = 'short', defaultValue = 35, min = 0, max = 35) cmds.select(None)
def claw(ref): # duplicate geo selection = cmds.ls(sl=True) for locator in selection: split = locator.split("section_") name = "%sclaw_%s" % (split[0], split[1].replace("locator", "C")) bind = "bind_%s" % name old_name = "old_%s" % name old_bind = "old_%s" % bind cmds.rename(name, old_name) cmds.rename(bind, old_bind) cmds.duplicate(ref, rr=True, un=True, name=bind) cmds.duplicate(bind, name=name) shape = cmds.listRelatives(bind, s=True)[0] claw_bs = cmds.listConnections(shape, type="blendShape", s=True)[0] cmds.connectAttr(locator + ".parameter", claw_bs + ".tentacle_claw") cmds.scaleConstraint(locator, bind, maintainOffset=False) cmds.parentConstraint(locator, bind, maintainOffset=False) bs = cmds.blendShape(bind, name, origin="world") cmds.setAttr(bs[0] + ".w[0]", 1) cmds.parent(name, cmds.listRelatives(old_name, p=True)[0]) cmds.parent(bind, cmds.listRelatives(old_bind, p=True)[0]) cmds.delete(old_name, old_bind)
def tip(ref): selection = cmds.ls(sl=True) for tip in selection: bind = tip name = tip.replace("bind_", "") old_name = "old_%s" % name old_bind = "old_%s" % bind cmds.rename(name, old_name) cmds.rename(bind, old_bind) cmds.duplicate(ref, rr=True, un=True, name=bind) cmds.duplicate(bind, name=name) bs = cmds.blendShape(bind, name, origin="world") cmds.setAttr(bs[0] + ".w[0]", 1) joint = cmds.listConnections(cmds.parentConstraint(old_bind, q=True), type="joint")[0] cmds.parentConstraint(joint, bind, maintainOffset=False) cmds.parent(name, cmds.listRelatives(old_name, p=True)[0]) cmds.parent(bind, cmds.listRelatives(old_bind, p=True)[0]) cmds.delete(old_name, old_bind)
def cut_one_with_one(cutter, target): print 'Cutting 1:1 %s with %s' % (target, cutter) # Duplicate targets targetA = cmds.duplicate(target, returnRootsOnly=True)[0] targetB = cmds.duplicate(target, returnRootsOnly=True)[0] prep(targetA) prep(targetB) cmds.delete(target) # Set up cutters cutterA = cmds.duplicate(cutter, returnRootsOnly=True)[0] cutterB = cmds.duplicate(cutter, returnRootsOnly=True)[0] prep(cutterA) prep(cutterB) # Flip second cutter's normals cmds.polyNormal(cutterB, normalMode=0, userNormalMode=0, constructionHistory=0) # Perform intersections newTargetA = cmds.polyBoolOp(cutterA, targetA, op=3, constructionHistory=False)[0] newTargetB = cmds.polyBoolOp(cutterB, targetB, op=3, constructionHistory=False)[0] return [newTargetA, newTargetB]
def __init__(self, curve_sel, vertex_list): self.curve_sel = curve_sel self.verts = vertex_list self.find_length = Find_Out() self.link_length = self.find_length.edge_length(self.verts) self.chain_length = self.find_length.curve_length(self.curve_sel) self.link_total = int(self.chain_length/self.link_length) cmds.duplicate(self.curve_sel, n = 'buildCurve') cmds.rebuildCurve('buildCurve', ch = 1, rpo = 1, rt = 0, end = 1, kr = 2, kep = 1, kt = 0, kcp = 0, s = self.link_total/2, d = 3, tol = 0.01 ) self.num_cv = int(cmds.getAttr ('buildCurve.degree'))+ (cmds.getAttr ('buildCurve.spans')) for dummy_cv in range(self.num_cv): dummy_cv_pos = (cmds.getAttr ('buildCurve.cv['+ str(dummy_cv) +']')) if dummy_cv == 0: cmds.joint(n=self.curve_sel+'_jointRoot',p = dummy_cv_pos[0]) elif dummy_cv == self.num_cv - 1: cmds.joint(n=self.curve_sel+'_jointEnd', p = dummy_cv_pos[0]) else: cmds.joint(n=self.curve_sel+'_joint_'+(str(dummy_cv)),p = dummy_cv_pos[0]) cmds.delete('buildCurve') cmds.ikHandle( sj = (self.curve_sel+'_jointRoot'), ee = (self.curve_sel+'_jointEnd'), c = self.curve_sel, sol = 'ikSplineSolver', scv = 0, pcv = 0, ccv = 0, ns = 4)
def axisPanelCreate(self , planeName , cur , axis): CurveEps = mc.ls(cur + '.ep[:]',fl = True) CurveCvs = mc.ls(cur + '.cv[:]',fl = True) cvworlds = [] if axis == 'auto': for i in range(len(CurveCvs)): cv = CurveCvs[i] cvworld = mc.xform(cv,q = True,ws = True,t = True) cvworlds.append(cvworld) axisFacet = mc.polyCreateFacet(p = cvworlds,ch = False,name = planeName + '_axis_Facet')[0] else: curOffsetGrp = mc.group(em = True,name = planeName + '_axisPanelOffset') curOffsetZero = mc.group(curOffsetGrp,name = curOffsetGrp + '_zero') axisCurve01 = mc.duplicate(cur)[0] axisCurve02 = mc.duplicate(cur)[0] mc.parent(axisCurve01,curOffsetGrp) mc.setAttr(curOffsetGrp + '.t' + axis,1) mc.parent(axisCurve01,w = True) mc.parent(axisCurve02,curOffsetGrp) mc.setAttr(curOffsetGrp + '.t' + axis,0) mc.parent(axisCurve02,w = True) axisFacet = mc.loft(axisCurve01,axisCurve02,ch = 1,u = 1,c = 0,ar = 1,d = 3,ss = 1,rn = 0,po = 1,rsn = True,name = planeName + '_axis_Facet')[0] mc.select(axisFacet) mc.DeleteHistory() mc.setAttr(curOffsetGrp + '.t' + axis,1) mc.delete(curOffsetZero,axisCurve01,axisCurve02) return axisFacet
def add_blink(upperLidCurve, lowerLidCurve, upperLidCtrlCurve, lowerLidCtrlCurve): # duplicate upLid HiRes curve for upLidBlink curve # duplicate lowerLid HiRes curve for lowerLidBlink curve upperLidBlinkCurve = cmds.duplicate(upperLidCurve, name="%sBlink"%upperLidCurve)[0] lowerLidBlinkCurve = cmds.duplicate(lowerLidCurve, name="%sBlink"%lowerLidCurve)[0] # duplicate upLid loRes curve for blinkCurve blinkCurve = cmds.duplicate(upperLidCtrlCurve, name="blinkCurve")[0] # blendShape upLid loRes and lowerLid loRes into blinkCurve(0.7/0.3) bsNode = cmds.blendShape(upperLidCtrlCurve, lowerLidCtrlCurve, blinkCurve)[0] # wireDeformer blinkCurve to upLidBlink at blendShape(1.0/0) cmds.blendShape(bsNode, e=True, w=[(0,1), (1,0)]) upperWireNode, upperWire, upperWireBase = utils.wire_deformer(blinkCurve, upperLidBlinkCurve) # wireDeformer blinkCurve to lowerLidBlink at blendShape(0/0.1) cmds.blendShape(bsNode, e=True, w=[(0,0), (1,1)]) lowerWireNode, lowerWire, lowerWireBase = utils.wire_deformer(blinkCurve, lowerLidBlinkCurve) # default blendshape setting cmds.blendShape(bsNode, e=True, w=[(0,0.5), (1,0.5)]) # blendShape upLidBlink into upLid hiRes # blendShape lowerLidBlink into lowerLid hiRes cmds.blendShape(upperLidBlinkCurve, upperLidCurve) cmds.blendShape(lowerLidBlinkCurve, lowerLidCurve)
def runTest(self): try: import maya.cmds as cmds def getShape(trans): return cmds.listRelatives(trans, children=True, shapes=True)[0] cmds.file(new=1, f=1) shapeTransform = cmds.polyCube(name='singleShapePoly')[0] origShape = getShape(shapeTransform) dupeTransform1 = cmds.duplicate(origShape, parentOnly=1)[0] cmds.parent(origShape, dupeTransform1, shape=True, addObject=True, relative=True) dupeTransform2 = cmds.duplicate(dupeTransform1)[0] cmds.delete(dupeTransform1) dupeShape = getShape(dupeTransform2) # In maya 2014, this raises: # Error: Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Source is not connected. # Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Destination attribute must be writable. # Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Destination attribute must be writable. # Traceback (most recent call last): # File "<maya console>", line 13, in <module> # RuntimeError: Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Source is not connected. # Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Destination attribute must be writable. # Connection not made: 'singleShapePolyShape2.instObjGroups[1]' -> 'initialShadingGroup.dagSetMembers[2]'. Destination attribute must be writable. # cmds.parent(dupeShape, shapeTransform, shape=True, addObject=True, relative=True) except Exception: pass else: self.fail("ShapeParentInstance bug fixed!")
def cleanDuplicate(targetObj): """ arguments: targetObj - name of mesh that you want to duplicate todo: 1. check that targetObj is a valid mesh 2. currently resets deformer envelopes to 1... need to remember original value? 3. cleanup intermediate object(s), possibly by obj export/import. """ # get list of deformers on targetObj allDeformers = meval('findRelatedDeformer("%s")'%targetObj) # disable all deformers by setting envelope to 0 for eachDfm in allDeformers: print eachDfm mc.setAttr('%s.envelope'%eachDfm, 0) # make duplicate mc.duplicate(targetObj, n='%s_cleanDuplicate'%targetObj) # re-enable all deformers by setting envelope to 1 for eachDfm in allDeformers: mc.setAttr('%s.envelope'%eachDfm, 1)
def ctrl_pointer(): mel.eval('curve -d 1 -p -1 0 0 -p 1 0 0 -p 1 1 0 -p 1 2 0 -p 1 3 0 -p 2 3 0 -p 0 5 0 -p -2 3 0 -p -1 3 0 -p -1 2 0 -p -1 1 0 -p -1 0 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11') ctrl = cmds.ls(sl=True) cmds.duplicate(rr=True) ctrl2 = cmds.ls(sl=True) cmds.setAttr(ctrl2[0] + '.rotateY', 90) print 'Curves have been positioned.' cmds.makeIdentity(apply=True, t=1, r=1, s=1, n=0) print 'Freezing transforms on curves.' cmds.select(ctrl, r=True) cmds.pickWalk(d='Down') cmds.select(ctrl2, add=True) cmds.parent(r=True, s=True) print 'Curves have been parented into single curve.' cmds.select(ctrl, r=True) mel.eval('doDelete') print 'Unsuded groups have been deleted.' cmds.select(ctrl2) mel.eval('CenterPivot') print 'Curve has been selected and its pivot has been centered.'
def extractSplits(): splits = cmds.ls(sl=True) bshp = "{0}_BSHP".format(splits[0]) # first target should be set to 1, but just in case reset them all targets = getTargets(bshp) for target in targets: blendName = "{0}.{1}".format(bshp, target) cmds.setAttr( blendName, 0 ) for target in targets: blendName = "{0}.{1}".format(bshp, target) cmds.setAttr( blendName, 1 ) # duplicate each split for i, split in enumerate(splits): cmds.select(split) # name extraction extract = target.split("_") name = ("{0}_{1}{2}_{3}".format(extract[0], extract[1], str(i+1), extract[2])) cmds.duplicate(n=name) cmds.setAttr( blendName, 0)
def getMeshVertexData( mesh ): returnData = [] exportObject = 'bwExportObject' cmds.duplicate( mesh, n=exportObject ) cmds.polyTriangulate(exportObject) numOfFaces = cmds.polyEvaluate(exportObject, f=True ) for i in xrange(0, numOfFaces): faceSelect = exportObject + '.f[' + str(i) + ']' fVertices = [] fVertices = cmds.polyListComponentConversion(faceSelect, ff = True, tvf = True) fVertices = cmds.filterExpand(fVertices, sm = 70, ex = True) print fVertices for vertex in fVertices: faceDict = {} vName = cmds.polyListComponentConversion(vertex, fvf = True, tv = True) xyz = [] xyz = cmds.xform(vName, q = True, os = True, t = True) faceDict['x'] = round(xyz[0], 2) faceDict['y'] = round(xyz[1], 2) faceDict['z'] = round(xyz[2], 2) normal = [] normal = cmds.polyNormalPerVertex(vertex, q = True, xyz = True) faceDict['xN'] = round(normal[0], 2) faceDict['yN'] = round(normal[1], 2) faceDict['zN'] = round(normal[2], 2) # vuv = [] # vuv = cmds.polyListComponentConversion(vertex, fvf = True, tuv = True) # uvCoords = [] # uvCoords = cmds.polyEditUV(vuv[0], q = True, u = True, v = True) # faceDict['u'] = round(uvCoords[0], 2) # faceDict['v'] = round(uvCoords[0], 2) returnData.append(faceDict) cmds.delete(exportObject) return json.dumps(returnData)
def mirror_shape(path): """In addition to mirroring transforms, also mirror shapes Arguments: path (str): Path to transform with shapes to mirror Returns: Path to mirrored transform """ mirrored_transform = mirror_transform(path) mirrored_original = cmds.duplicate(path, name=path + "_duplicate") mirrored_group = cmds.createNode('transform', name=path + "_transform") cmds.parent(mirrored_original[0], mirrored_group) cmds.setAttr(mirrored_group + ".sx", -1) blendshape = cmds.blendShape((mirrored_original[0], mirrored_transform), origin='world') cmds.setAttr(blendshape[0] + "." + mirrored_original[0], 1) mirrored_with_shape = cmds.duplicate(mirrored_transform, inputConnections=True, returnRootsOnly=True) cmds.delete([mirrored_transform, mirrored_group]) cmds.select(mirrored_with_shape, replace=True) return mirror_transform
def duplicateObject(self, objName, modifiedName, *args): # ベースオブジェクトを選択 cmds.select(str(objName), r=True) # 複製しXMLと合致しなかった名前にリネーム cmds.duplicate(n=modifiedName, rr=True)
def buildPlanes(block): buildings = [] faces = block.faceList drop = block.dropRate i = 0 sidewalkHeight = max(block.heightRange)/160.0 for f in faces: if(random.random() >= block.dropRate): height = 1.0*random.choice(block.heightRange) levels = random.choice(block.levelRange) #get the midpoint of the current face verts = makeVertList(cmds.xform(f, q=True, t=True)) midpoint = getMidpoint(verts, True) #make a duplicate of the parent plane cmds.select(block.parentPlane) dupName = block.name + "building_"+str(i) dupFace = dupName + ".f[0]" cmds.duplicate(name=dupName) cmds.xform(t=midpoint) #create building and add it to building list makeBuilding(dupFace, levels, height, sidewalkHeight) buildings += [dupName] i += 1 if(not updateProgressWindow(i, len(faces))): break cmds.group(buildings, name=block.name + "_buildings") killProgressWindow()
def splitShapeSetup(): # create 3 splitOutput meshes that will be painted # start with creating the splitters selection = cmds.ls(sl=True) meshList = selection[:-1] base = selection[-1] splitters = [] blends = [] meshes = ["A", "B", "C"] inputMeshList = meshList # first target plays an important role, this is the one we're going to default turn on and align to in tx first = meshList[0] for i, letter in enumerate(meshes): # create splitters split = "{0}_split{1}".format(base, letter) cmds.duplicate(base, n=split) cmds.delete(cmds.parentConstraint(first, split)) # how far to move the dup dist = (int(i) + 1) * 10 cmds.move(dist, 0, 0, split, r=True) blend = "{0}_BSHP".format(split) cmds.select(split) cmds.blendShape(n=blend) splitters.append(split) blends.append(blend) # add blends and set them too yada yada blendDrivers = [] blendDrivers = blendDrivers + meshList for i, split in enumerate(splitters): # connections? cmds.select(blendDrivers) cmds.select(split, tgl=True) mel.eval("performBlendShapeAdd 0;") blendDrivers.append(split) # if a splitter, set to -1 for s in splitters: splitBshp = "{0}.{1}".format(blends[i], s) if cmds.objExists(splitBshp): cmds.setAttr(splitBshp, -1) # Turn on the first. Just as a default for blend in blends: cmds.setAttr("{0}.{1}".format(blend, first), 1) # connect all meshList input shapes to each other for i, target in enumerate(inputMeshList): print inputMeshList if blend != blends[0]: cmds.connectAttr( "{0}.{1}".format(blends[0], target), "{0}.{1}".format(blend, target) )
def LoadDelta(Args): global adress # Open dialog window to choose directory to load delta folder = cmds.fileDialog2( cap='Choose directory to load Delta', fm=3, dialogStyle=1 ) adress = folder[0]+"\\" pathList_cleared = [] targetBlendDict = {} named_targetBlendDict = {} print "Loading Delta :)" # Getting .bsp files from choosen folder pathList = os.listdir( adress ) if len(pathList) == 0: print "Folder is empty" for element in pathList: if '.bsp' in element: pathList_cleared.append( element ) else: print 'wrong type - ', element pathList = pathList_cleared headObj = cmds.ls( sl=True ) object_qnty_check(headObj) headObject = headObj[0] step = 25 for i in range( len(pathList) ): start_time = timeit.default_timer() named_targetBlendDict.clear() path_name = open( adress+pathList[i],'r' ) DeltaDict = pickle.load( path_name ) targetBlendDict.clear() new_name = pathList[i].split('.')[0] cmds.duplicate( headObj[0], n=headObject+'_' + new_name ) cmds.select( headObject+'_'+new_name ) cmds.move( step, 0, 0 ) step += 25 for key in compOpacities: weight = compOpacities.get(key) x = baseVertDict[key][0] + (DeltaDict[key][0] * weight) y = baseVertDict[key][1] + (DeltaDict[key][1] * weight) z = baseVertDict[key][2] + (DeltaDict[key][2] * weight) targetBlendDict[key] = [x, y, z] copy_headObj = cmds.ls( sl=True ) for head in copy_headObj: for i in targetBlendDict: named_targetBlendDict[head+'.vtx' + str(i)] = targetBlendDict[i] for head in copy_headObj: for vert, value in named_targetBlendDict.iteritems(): cmds.xform( vert, t=value ) print "Loading time - ", head, ( timeit.default_timer() - start_time ) cmds.softSelect( sse=1 ) names = cmds.listAttr( "blendShape1", m=True, k=True )[1:] fullNames = [] for i in names: fullNames.append( headObj[0] + '_' + i ) cmds.blendShape( fullNames, headObj ) cmds.delete( fullNames ) return adress
def buildPlanes(self): """ Creates buildings on new planes with probability of 1-SPAWN_CHANCE """ buildings = [] i = 0 sidewalkHeight = self.maxHeight/160.0 for f in self.faceList: if(random.random() >= self.dropRate): height = self.minHeight +\ random.random()*(self.maxHeight-self.minHeight) levels = random.choice(self.levelRange) #get the midpoint of the current face verts = makeVertList(cmds.xform(f, q=True, t=True)) midpoint = getMidpoint(verts, True) #make a duplicate of the parent plane dupName = self.name + "building_"+str(i) dupFace = dupName + ".f[0]" cmds.duplicate(self.sourcePlane, name=dupName) cmds.xform(t=midpoint) #create building and add it to building list self.makeBuilding(dupFace, levels, height, sidewalkHeight) buildings += [dupName] i += 1 if(not updateProgressWindow(i, len(self.faceList))): break cmds.group(buildings, name=self.name + "_buildings") killProgressWindow()
def ThreeJointSetup(self, RKarmSels): RKarmSels = RKarmSels FKJoints = cmds.duplicate(RKarmSels, name=RKarmSels[0] + "_FK") IKJoints = cmds.duplicate(RKarmSels, name=RKarmSels[0] + "_IK") for RKJoint in RKarmSels: cmds.select(RKJoint) cmds.addAttr(attributeType="float", longName='IK_Weight', defaultValue=1, minValue=0, maxValue=1, hidden=False, readable=True, keyable=True) cmds.addAttr(attributeType="float", longName='FK_Weight', defaultValue=1, minValue=0, maxValue=1, hidden=False, readable=True, keyable=True) # -- FK setup -- # def FKJointSetup(self, fKtoSetup): ctrlGroupArray = [] ctrlArray = [] for object in fKtoSetup: self.objectPOS = cmds.xform(object, q=1, t=1, ws=True) self.objectROT = cmds.xform(object, q=1, ro=1, ws=True) self.ctrlName = object + "_Ctrl" self.ourControl = cmds.circle(c=(0, 0, 0), n=self.ctrlName) self.ourControlGrp = cmds.group(n=(object + "_Ctrl_Grp"), em=True) cmds.move(self.objectPOS[0], self.objectPOS[1], self.objectPOS[2], self.ourControlGrp) cmds.rotate(self.objectROT[0], self.objectROT[1], self.objectROT[2], self.ourControlGrp) cmds.parent(self.ctrlName, self.ourControlGrp) cmds.move(0, 0, 0, self.ourControl, ls=True) cmds.rotate(0, 0, 0, self.ourControl) cmds.parentConstraint(self.ourControl, object, mo=True) cmds.scaleConstraint(self.ourControl, object, mo=True) ctrlArray.append(self.ourControl) ctrlGroupArray.append(self.ourControlGrp) cmds.parentConstraint(ctrlArray[0], ctrlGroupArray[1], mo=True) cmds.parentConstraint(ctrlArray[1], ctrlGroupArray[2], mo=True) # -- IK setup -- # def StretchyIkSetup(self, armSels): if hasattr(armSels, '__getitem__'): #declare variables for the various joints self.firstJointPos = cmds.xform(armSels[0], q=1, ws=1, t=1) self.secondJointPos = cmds.xform(armSels[1], q=1, ws=1, t=1) self.lastJointPos = cmds.xform(armSels[2], q=1, ws=1, t=1) self.lastJointRot = cmds.xform(armSels[2], q=1, ws=1, ro=1) self.secondJointPosLocal = cmds.xform(armSels[1], q=1, t=1) self.lastJointPosLocal = cmds.xform(armSels[2], q=1, t=1) #Create an IK handle on first and last Joints. self.tempIKName = str(armSels[0]) + "IK_Hndl" self.ikName = cmds.ikHandle(ee=armSels[2], sj=armSels[0], n=self.tempIKName) #Create locators for the first and last joint. self.jnt1Loc = cmds.spaceLocator(p=(0, 0, 0)) cmds.move(self.firstJointPos[0], self.firstJointPos[1], self.firstJointPos[2]) self.jnt2Loc = cmds.spaceLocator(p=(0, 0, 0)) cmds.move(self.lastJointPos[0], self.lastJointPos[1], self.lastJointPos[2]) self.jnt1LocShape = cmds.listRelatives(self.jnt1Loc, s=1) self.jnt2LocShape = cmds.listRelatives(self.jnt2Loc, s=1) #create a control for the IK handle, give it a stretchy attribute. self.ikCtrlTempName = str(armSels[0]) + "_IK_Ctrl" self.ikJointControl = cmds.circle(c=(0, 0, 0), n=self.ikCtrlTempName) cmds.addAttr(ln="Stretchy", at="float", keyable=True) self.ourControlGrp = cmds.group(n=(str(armSels[0]) + "_IK_Ctrl_Grp"), em=True) cmds.move(self.lastJointPos[0], self.lastJointPos[1], self.lastJointPos[2], self.ourControlGrp, ws=1) cmds.rotate(self.lastJointRot[0], self.lastJointRot[1], self.lastJointRot[2], self.ourControlGrp, ws=1) cmds.parent(self.ikCtrlTempName, self.ourControlGrp) cmds.move(0, 0, 0, self.ikJointControl, ls=True) cmds.rotate(0, 0, 0, self.ikJointControl) #create a "Distance between" Node for... well. getting the distance between the two nodes. self.distanceTest = str( cmds.shadingNode('distanceBetween', asUtility=1)) #create all of these nodes for all the different things we need to set up for the system. self.arm01DistanceNode = str( cmds.shadingNode('multiplyDivide', asUtility=1)) cmds.setAttr((self.arm01DistanceNode + ".input1X"), self.secondJointPosLocal[0]) self.arm02DistanceNode = str( cmds.shadingNode('multiplyDivide', asUtility=1)) cmds.setAttr((self.arm02DistanceNode + ".input1X"), self.lastJointPosLocal[0]) self.chainLengthPMA = str( cmds.shadingNode('plusMinusAverage', asUtility=1)) self.distanceScalar = str( cmds.shadingNode('multiplyDivide', asUtility=1)) cmds.setAttr((self.distanceScalar + ".operation"), 2) self.stretchCondition = str( cmds.shadingNode('condition', asUtility=1)) cmds.setAttr((self.stretchCondition + ".operation"), 2) self.colorBlendNode = str( cmds.shadingNode('blendColors', asUtility=1)) cmds.setAttr((self.colorBlendNode + ".color2R"), 1) self.arm01ScaleMD = str( cmds.shadingNode('multiplyDivide', asUtility=1)) self.arm02ScaleMD = str( cmds.shadingNode('multiplyDivide', asUtility=1)) #connect them attributes self.LinkConstraints(self.jnt1LocShape[0], "worldPosition[0]", self.distanceTest, "point1") self.LinkConstraints(self.jnt2LocShape[0], "worldPosition[0]", self.distanceTest, "point2") self.LinkConstraints(self.arm01DistanceNode, "outputX", self.chainLengthPMA, "input1D[0]") self.LinkConstraints(self.arm02DistanceNode, "outputX", self.chainLengthPMA, "input1D[1]") self.LinkConstraints(self.chainLengthPMA, "output1D", self.distanceScalar, "input2X") self.LinkConstraints(self.distanceTest, "distance", self.distanceScalar, "input1X") self.LinkConstraints(self.distanceTest, "distance", self.stretchCondition, "firstTerm") self.LinkConstraints(self.chainLengthPMA, "output1D", self.stretchCondition, "secondTerm") self.LinkConstraints(self.distanceScalar, "outputX", self.stretchCondition, "colorIfTrueR") self.LinkConstraints(self.stretchCondition, "outColorR", self.colorBlendNode, "color1R") self.LinkConstraints(self.arm01DistanceNode, "outputX", self.arm01ScaleMD, "input1X") self.LinkConstraints(self.arm02DistanceNode, "outputX", self.arm02ScaleMD, "input1X") self.LinkConstraints(self.colorBlendNode, "outputR", self.arm01ScaleMD, "input2X") self.LinkConstraints(self.colorBlendNode, "outputR", self.arm02ScaleMD, "input2X") self.LinkConstraints(self.arm01ScaleMD, "outputX", armSels[1], "translateX") self.LinkConstraints(self.arm02ScaleMD, "outputX", armSels[2], "translateX") self.LinkConstraints((str(armSels[0]) + "_IK_Ctrl"), "Stretchy", self.colorBlendNode, "blender") cmds.parentConstraint(self.ikCtrlTempName, self.tempIKName, mo=True) cmds.parentConstraint(self.ikCtrlTempName, self.jnt2Loc, mo=True) cmds.scaleConstraint(self.ikCtrlTempName, self.tempIKName, mo=True) cmds.scaleConstraint(self.ikCtrlTempName, self.jnt2Loc, mo=True) else: print("Generic Error Message") return # ---------------------- RK Initalizer ---------------- def RKInitalizer( self, IKChain, FKChain, RKChain, ): #setup initial joint chain for RK i = 0 for chain in RKChain: RKTempString = str(RKChain[i]) IKTempString = str(IKChain[i]) FKTempString = str(FKChain[i]) print(RKTempString, IKTempString) constraintNumber = cmds.parentConstraint(IKChain[i], FKChain[i], RKChain[i], name=str(RKChain[i]) + "_Parent_Constraint") print(str(RKChain[i]) + "_Parent_Constraint") # LinkConstraints(self, RKChain[i], 'FK_Weight', constraintNumber,FKChain[i] + "W" +[i]) cmds.connectAttr((str(RKTempString) + "." + 'IK_Weight'), (str(RKChain[i]) + "_Parent_Constraint" + "." + str(IKTempString) + "W0"), f=1) cmds.connectAttr((str(RKTempString) + "." + 'FK_Weight'), (str(RKChain[i]) + "_Parent_Constraint" + "." + str(FKTempString) + "W1"), f=1) i = i + 1 # -- Function Calls -- # # TESTING, OK!! ---- FKJointSetup(self, FKJoints) StretchyIkSetup(self, IKJoints) RKInitalizer(self, IKJoints, FKJoints, RKarmSels)
def HandControls(*args): cmds.select ("L_Palm_CC") cmds.parent (w = True) cmds.mirrorJoint ("L_Palm_CC", searchReplace = ("L_", "R_"), mirrorYZ = True, mirrorBehavior = True ) if cmds.objExists ('L_arm_4'): cmds.parent ("L_Palm_CC","L_arm_4") cmds.parent ("R_Palm_CC","R_arm_4") cmds.delete ("HandPosition") #Fingers Controls radio = 1 if cmds.objExists ('L_Thumb01_JJ'): for Thumb in range (1,4): cmds.circle (n = "L_Thumb0" + str (Thumb) + "_CC", nr = (1,0,0), r = radio) cmds.group (n= 'L_Thumb0' + str (Thumb) + '_CC' + 'GRP') cmds.pointConstraint ('L_Thumb0' + str (Thumb) + '_JJ', 'L_Thumb0' + str (Thumb) + '_CC' + 'GRP') cmds.orientConstraint ('L_Thumb0' + str (Thumb) + '_JJ', 'L_Thumb0' + str (Thumb) + '_CC'+ 'GRP', mo = False ) cmds.delete ("L_Thumb0" + str (Thumb)+"_CCGRP_pointConstraint1", "L_Thumb0" + str (Thumb)+"_CCGRP_orientConstraint1") cmds.orientConstraint ('L_Thumb0' + str (Thumb) + '_CC', 'L_Thumb0' + str (Thumb) + '_JJ') cmds.setAttr('L_Thumb0' + str (Thumb) + '_CC' + "Shape.overrideEnabled", True ) cmds.setAttr('L_Thumb0' + str (Thumb) + '_CC' + "Shape.overrideColor", 6 ) cmds.parent ('L_Thumb02_CCGRP','L_Thumb01_CC') cmds.parent ('L_Thumb03_CCGRP','L_Thumb02_CC') if cmds.objExists ('L_Index01_JJ'): for Index in range (1,5): cmds.circle (n = "L_Index0" + str (Index) + "_CC", nr = (1,0,0), r = radio) cmds.group (n= 'L_Index0' + str (Index) + '_CC' + 'GRP') cmds.pointConstraint ('L_Index0' + str (Index) + '_JJ', 'L_Index0' + str (Index) + '_CC' + 'GRP') cmds.orientConstraint ('L_Index0' + str (Index) + '_JJ', 'L_Index0' + str (Index) + '_CC'+ 'GRP', mo = False ) cmds.delete ("L_Index0" + str (Index)+"_CCGRP_pointConstraint1", "L_Index0" + str (Index)+"_CCGRP_orientConstraint1") cmds.orientConstraint ('L_Index0' + str (Index) + '_CC', 'L_Index0' + str (Index) + '_JJ') cmds.setAttr('L_Index0' + str (Index) + '_CC' + "Shape.overrideEnabled", True ) cmds.setAttr('L_Index0' + str (Index) + '_CC' + "Shape.overrideColor", 6 ) cmds.parent ('L_Index02_CCGRP','L_Index01_CC') cmds.parent ('L_Index03_CCGRP','L_Index02_CC') cmds.parent ('L_Index04_CCGRP','L_Index03_CC') if cmds.objExists ('L_Middle01_JJ'): for Middle in range (1,5): cmds.circle (n = "L_Middle0" + str (Middle) + "_CC", nr = (1,0,0), r = radio) cmds.group (n= 'L_Middle0' + str (Middle) + '_CC' + 'GRP') cmds.pointConstraint ('L_Middle0' + str (Middle) + '_JJ', 'L_Middle0' + str (Middle) + '_CC' + 'GRP') cmds.orientConstraint ('L_Middle0' + str (Middle) + '_JJ', 'L_Middle0' + str (Middle) + '_CC'+ 'GRP', mo = False ) cmds.delete ("L_Middle0" + str (Middle)+"_CCGRP_pointConstraint1", "L_Middle0" + str (Middle)+"_CCGRP_orientConstraint1") cmds.orientConstraint ('L_Middle0' + str (Middle) + '_CC', 'L_Middle0' + str (Middle) + '_JJ') cmds.setAttr('L_Middle0' + str (Middle) + '_CC' + "Shape.overrideEnabled", True ) cmds.setAttr('L_Middle0' + str (Middle) + '_CC' + "Shape.overrideColor", 6 ) cmds.parent ('L_Middle02_CCGRP','L_Middle01_CC') cmds.parent ('L_Middle03_CCGRP','L_Middle02_CC') cmds.parent ('L_Middle04_CCGRP','L_Middle03_CC') if cmds.objExists ('L_Ring01_JJ'): for Ring in range (1,5): cmds.circle (n = "L_Ring0" + str (Ring) + "_CC", nr = (1,0,0), r = radio) cmds.group (n= 'L_Ring0' + str (Ring) + '_CC' + 'GRP') cmds.pointConstraint ('L_Ring0' + str (Ring) + '_JJ', 'L_Ring0' + str (Ring) + '_CC' + 'GRP') cmds.orientConstraint ('L_Ring0' + str (Ring) + '_JJ', 'L_Ring0' + str (Ring) + '_CC'+ 'GRP', mo = False ) cmds.delete ("L_Ring0" + str (Ring)+"_CCGRP_pointConstraint1", "L_Ring0" + str (Ring)+"_CCGRP_orientConstraint1") cmds.orientConstraint ('L_Ring0' + str (Ring) + '_CC', 'L_Ring0' + str (Ring) + '_JJ') cmds.setAttr('L_Ring0' + str (Ring) + '_CC' + "Shape.overrideEnabled", True ) cmds.setAttr('L_Ring0' + str (Ring) + '_CC' + "Shape.overrideColor", 6 ) cmds.parent ('L_Ring02_CCGRP','L_Ring01_CC') cmds.parent ('L_Ring03_CCGRP','L_Ring02_CC') cmds.parent ('L_Ring04_CCGRP','L_Ring03_CC') if cmds.objExists ('L_Pinky01_JJ'): for Pinky in range (1,5): cmds.circle (n = "L_Pinky0" + str (Pinky) + "_CC", nr = (1,0,0), r = radio) cmds.group (n= 'L_Pinky0' + str (Pinky) + '_CC' + 'GRP') cmds.pointConstraint ('L_Pinky0' + str (Pinky) + '_JJ', 'L_Pinky0' + str (Pinky) + '_CC' + 'GRP') cmds.orientConstraint ('L_Pinky0' + str (Pinky) + '_JJ', 'L_Pinky0' + str (Pinky) + '_CC'+ 'GRP', mo = False ) cmds.delete ("L_Pinky0" + str (Pinky)+"_CCGRP_pointConstraint1", "L_Pinky0" + str (Pinky)+"_CCGRP_orientConstraint1") cmds.orientConstraint ('L_Pinky0' + str (Pinky) + '_CC', 'L_Pinky0' + str (Pinky) + '_JJ') cmds.setAttr('L_Pinky0' + str (Pinky) + '_CC' + "Shape.overrideEnabled", True ) cmds.setAttr('L_Pinky0' + str (Pinky) + '_CC' + "Shape.overrideColor", 6 ) cmds.parent ('L_Pinky02_CCGRP','L_Pinky01_CC') cmds.parent ('L_Pinky03_CCGRP','L_Pinky02_CC') cmds.parent ('L_Pinky04_CCGRP','L_Pinky03_CC') cmds.select (clear = True) cmds.group (n = 'L_HandControls_GRP', em = True) cmds.parent ('L_Thumb01_CCGRP','L_Index01_CCGRP','L_Middle01_CCGRP','L_Ring01_CCGRP','L_Pinky01_CCGRP','L_HandControls_GRP' ) cmds.xform ('L_HandControls_GRP', piv = (0,0,0) ,ws=True) cmds.duplicate ('L_HandControls_GRP', n= 'R_HandControls_GRP') cmds.setAttr ("R_HandControls_GRP.scaleX", -1) cmds.makeIdentity ('R_HandControls_GRP',a = True, t = 1, r = 1) cmds.select ('R_HandControls_GRP') cmds.expression ( s= "searchReplaceNames \"L_\" \"R_\" \"hierarchy\";" , n = "Rename" , o = "" , ae= 0) cmds.delete ("Rename") #RightHand_CC.orient if cmds.objExists ('R_Thumb01_JJ'): for RThumb in range (1,4): cmds.orientConstraint ('R_Thumb0' + str (RThumb) + '_CC', 'R_Thumb0' + str (RThumb) + '_JJ', mo = True) cmds.setAttr('R_Thumb0' + str (RThumb) + '_CC' + "Shape.overrideColor", 13 ) if cmds.objExists ('R_Index01_JJ'): for RIndex in range (1,5): cmds.orientConstraint ('R_Index0' + str (RIndex) + '_CC', 'R_Index0' + str (RIndex) + '_JJ', mo = True) cmds.setAttr('R_Index0' + str (RIndex) + '_CC' + "Shape.overrideColor", 13 ) if cmds.objExists ('R_Middle01_JJ'): for RMiddle in range (1,5): cmds.orientConstraint ('R_Middle0' + str (RMiddle) + '_CC', 'R_Middle0' + str (RMiddle) + '_JJ', mo = True) cmds.setAttr('R_Middle0' + str (RMiddle) + '_CC' + "Shape.overrideColor", 13 ) if cmds.objExists ('R_Ring01_JJ'): for RRing in range (1,5): cmds.orientConstraint ('R_Ring0' + str (RRing) + '_CC', 'R_Ring0' + str (RRing) + '_JJ', mo = True) cmds.setAttr('R_Ring0' + str (RRing) + '_CC' + "Shape.overrideColor", 13 ) if cmds.objExists ('R_Pinky01_JJ'): for RPinky in range (1,5): cmds.orientConstraint ('R_Pinky0' + str (RPinky) + '_CC', 'R_Pinky0' + str (RPinky) + '_JJ', mo = True) cmds.setAttr('R_Pinky0' + str (RPinky) + '_CC' + "Shape.overrideColor", 13 ) cmds.parent ('L_HandControls_GRP','L_Palm_CC') cmds.parent ('R_HandControls_GRP','R_Palm_CC') cmds.select ('L_Palm_CC', 'L_Thumb01_JJ', 'L_Thumb02_JJ', 'L_Thumb03_JJ', 'L_Index01_JJ', 'L_Index02_JJ', 'L_Index03_JJ', 'L_Index04_JJ', 'L_Middle01_JJ', 'L_Middle02_JJ', 'L_Middle03_JJ', 'L_Middle04_JJ', 'L_Ring01_JJ', 'L_Ring02_JJ', 'L_Ring03_JJ', 'L_Ring04_JJ', 'L_Pinky01_JJ', 'L_Pinky02_JJ', 'L_Pinky03_JJ', 'L_Pinky04_JJ', 'R_Palm_CC', 'R_Thumb01_JJ', 'R_Thumb02_JJ', 'R_Thumb03_JJ', 'R_Index01_JJ', 'R_Index02_JJ', 'R_Index03_JJ', 'R_Index04_JJ', 'R_Middle01_JJ', 'R_Middle02_JJ', 'R_Middle03_JJ', 'R_Middle04_JJ', 'R_Ring01_JJ', 'R_Ring02_JJ', 'R_Ring03_JJ', 'R_Ring04_JJ', 'R_Pinky01_JJ', 'R_Pinky02_JJ', 'R_Pinky03_JJ', 'R_Pinky04_JJ' ) cmds.sets (n= 'BindThisToHands') print ('DONE')
def upperIKTwist(color, suffix, name, prefix, upperJnt, lowerJnt, sysGroup): print "START Building the " + suffix + " " + upperJnt + " UPPER IK twists---------------------------------------" #create a nice name name = prefix + name + suffix if name.find("_") == 0: name = name.partition("_")[2] # define the joints for this rig. upperjnt = prefix + upperJnt + suffix lowerjnt = prefix + lowerJnt + suffix #OLD - upperjnt_parent = "driver_" + prefix + "clavicle" + suffix upperjnt_parent = cmds.listRelatives(upperjnt, p=True)[0] driver_upperjnt = "driver_" + prefix + upperJnt + suffix driver_lowerjnt = "driver_" + prefix + lowerJnt + suffix numRolls = 0 for joint in [ "_twist_01", "_twist_02", "_twist_03", "_twist_04", "_twist_05", "_twist_06" ]: if cmds.objExists("driver_" + prefix + upperJnt + joint + suffix): numRolls = numRolls + 1 print "...There are a total of " + str(numRolls) + " to build." for i in range(int(numRolls)): print "...Building upper twist_0" + str(i + 1) upperjnt_twist = prefix + upperJnt + "_twist_0" + str(i + 1) + suffix driver_upperjnt_twist = "driver_" + prefix + upperJnt + "_twist_0" + str( i + 1) + suffix #################################### # Create a master group for the roll controls to be parented to. rollGrp = cmds.group(empty=True, name=upperjnt + "_roll_grp_0" + str(i + 1)) cmds.parent(rollGrp, sysGroup) cmds.parentConstraint(upperjnt_parent, rollGrp, mo=True) # Create the manual twist control if i == 0: twistCtrl = utils.createControl("circle", 15, upperjnt + "_twist_anim") else: twistCtrl = utils.createControl( "circle", 15, upperjnt + "_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_upperjnt_twist, 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_upperjnt_twist, twistCtrlGrp, mo=False)[0] cmds.delete(constraint) twistCtrlDeltoidOffsetGrp = cmds.group(empty=True, name=twistCtrl + "_deltOffset_grp") constraint = cmds.parentConstraint(driver_upperjnt_twist, twistCtrlDeltoidOffsetGrp, mo=False)[0] cmds.delete(constraint) cmds.parent(twistCtrl, twistCtrlDeltoidOffsetGrp) cmds.parent(twistCtrlDeltoidOffsetGrp, twistCtrlGrp) cmds.parent(twistCtrlGrp, rollGrp) cmds.makeIdentity(twistCtrl, t=1, r=1, s=1, apply=True) # 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=(upperjnt + "_twistCtrlVisUpper"), at='bool', dv=0, keyable=True) cmds.connectAttr("Rig_Settings." + upperjnt + "_twistCtrlVisUpper", twistCtrl + ".v") # add attr to rig settings for the twist ammount values cmds.select("Rig_Settings") cmds.addAttr(longName=(upperjnt + "_Twist" + str(i + 1) + "Amount"), defaultValue=0.5, minValue=0, maxValue=1, keyable=True) for u in range(int(i + 1)): cmds.setAttr( "Rig_Settings." + upperjnt + "_Twist" + str(u + 1) + "Amount", (1.0 / (i + 2.0) * ((2.0 - u) + (i - 1.0)))) #################################### # Create the twist rig on the shoulder without any extra controls. Those are added later. cmds.delete(upperjnt_twist + "_orientConstraint1") twistIKHandle = cmds.ikHandle(name="twistIKHandle_0" + str(i + 1) + "_" + upperjnt, sol="ikRPsolver", sj=upperjnt, ee=upperjnt_twist)[0] print "TWIST IK HANDLE IS: " + twistIKHandle cmds.setAttr(twistIKHandle + ".poleVectorX", 0) cmds.setAttr(twistIKHandle + ".poleVectorY", 0) cmds.setAttr(twistIKHandle + ".poleVectorZ", 0) cmds.parent(twistIKHandle, driver_upperjnt) driver_upperjnt_offset = cmds.duplicate(driver_upperjnt, po=True, name="driver_" + upperJnt + "_twistOffset_l")[0] cmds.parent(driver_upperjnt_offset, driver_upperjnt) twistOrntConst = cmds.orientConstraint(driver_upperjnt, upperjnt, driver_upperjnt_offset, mo=True)[0] cmds.setAttr(twistOrntConst + ".interpType", 2) twistMDNode = cmds.shadingNode("multiplyDivide", asUtility=True, name=driver_upperjnt_twist + "_MDnode") cmds.setAttr(twistMDNode + ".input2X", 1) cmds.setAttr(twistMDNode + ".input2Y", -1) cmds.connectAttr(driver_upperjnt_offset + ".rotateX", twistMDNode + ".input1X", force=True) cmds.connectAttr(driver_upperjnt + ".rotateX", twistMDNode + ".input1Y", force=True) cmds.connectAttr(twistMDNode + ".outputX", driver_upperjnt_twist + ".rx", force=True) cmds.connectAttr(twistMDNode + ".outputY", twistCtrlDeltoidOffsetGrp + ".rx", force=True) cmds.pointConstraint(driver_upperjnt_twist, twistCtrlGrp, mo=True) cmds.orientConstraint(driver_upperjnt_twist, twistCtrlGrp, mo=True) cmds.orientConstraint(twistCtrl, upperjnt_twist, mo=True) if cmds.objExists("deltoid_anim" + suffix): if suffix == "_l": cmds.connectAttr("deltoid_anim" + suffix + ".rotateX", twistIKHandle + ".twist", force=True) else: deltMDNode = cmds.shadingNode("multiplyDivide", asUtility=True, name=twistIKHandle + "_MDNode") cmds.setAttr(deltMDNode + ".input2X", -1) cmds.connectAttr("deltoid_anim" + suffix + ".rotateX", deltMDNode + ".input1X", force=True) cmds.connectAttr(deltMDNode + ".outputX", twistIKHandle + ".twist", force=True) reverseMDNode = cmds.shadingNode("reverse", asUtility=True, name=driver_upperjnt_offset + "_Reversenode") cmds.connectAttr("Rig_Settings." + upperjnt + "_Twist" + str(i + 1) + "Amount", reverseMDNode + ".inputX", force=True) cmds.connectAttr(reverseMDNode + ".outputX", twistOrntConst + "." + upperjnt + "W1", force=True) cmds.connectAttr("Rig_Settings." + upperjnt + "_Twist" + str(i + 1) + "Amount", twistOrntConst + "." + driver_upperjnt + "W0", force=True) print ".END Building the " + suffix + " " + upperJnt + " UPPER twists---------------------------------------"
"""one ctrl for all objects selected, select ctrl first""" import maya.cmds as cmds sel = cmds.ls(sl=True) origCtrl = "ctrl" print origCtrl cPos = cmds.xform(origCtrl, q=True, ws=True, rp=True) cRot = cmds.xform(origCtrl, q=True, ws=True, ro=True) ctrl = cmds.duplicate(origCtrl, n="{}Ctrl".format(obj))[0] #grp = cmds.group(em=True, n="{}Grp".format(ctrl)) #cmds.xform(grp, ws=True, t=cPos) #cmds.xform(grp, ws=True, ro=cRot) #cmds.parent(ctrl, grp) objPosList = [] objRotList = [] for x in range(0, len(sel)): obj = sel[x] pos = cmds.xform(obj, q=True, ws=True, rp=True) rot = cmds.xform(obj, q=True, ws=True, ro=True) objPosList.append(pos) objRotList.append(rot) #xPosList = [x[0] for x in objPosList] #yPosList = [x[1] for x in objPosList] #zPosList = [x[2] for x in objPosList] #xRotList = [x[0] for x in objRotList]
def get_splitValues(surface=None, values=[], mode='u', knotIndices=[], insertMin=False, insertMax=False, preInset=None, postInset=None, offset=None, curvesCreate=False, curvesConnect=False, connectionPoints=9): """ Function to split a surface :parameters: 'curve'(None) -- Curve to split curvesCreate(bool) - create new curves from the new values curvesConnect(bool) - whether to connect the first and last curves connectionPoints(int) - how many points of connection to use :returns list of values(list) hat tip: http://ewertb.soundlinker.com/mel/mel.074.php """ _str_func = 'get_splitValues' log.debug("|{0}| >> ".format(_str_func) + '-' * 80) _shape = SHAPES.get_nonintermediate(surface) if mode == 'u': l_base = get_dat(_shape, uKnots=True)['uKnots'] minKnot = ATTR.get(_shape, 'minValueU') maxKnot = ATTR.get(_shape, 'maxValueU') else: l_base = get_dat(_shape, vKnots=True)['vKnots'] minKnot = ATTR.get(_shape, 'minValueV') maxKnot = ATTR.get(_shape, 'maxValueV') l_sets = [] log.debug("|{0}| >> l_base: {1}".format(_str_func, l_base)) if knotIndices: values = [l_base[v] for v in knotIndices] for i, v in enumerate(values): log.debug("|{0}| >> Processing: {1} | {2}".format(_str_func, i, v) + "-" * 40) _last = False if v == values[-1]: log.debug("|{0}| >> last...".format(_str_func)) _last = True if preInset: v += preInset log.debug("|{0}| >> preinset: {1}".format(_str_func, v)) _l = [v] _stop = False for knot in l_base: if _stop or MATH.is_float_equivalent(knot, v) == v: continue log.debug("|{0}| >> checking knot: {1}".format(_str_func, knot)) if _last: if knot > v: _stop = True _l.append(knot) if knot > v or knot < v: if _last != True and knot < values[i + 1] and knot > v: _l.append(knot) log.debug("|{0}| >> knot add: {1}".format(_str_func, _l)) """ if v == values[-1]: if knot < maxKnot: _l.append(knot) elif _last != True and knot < values[i+1]: _l.append(knot)""" if _last and insertMax: l_add = [] for v2 in l_base: if v2 > _l[-1]: l_add.append(v2) for v2 in l_add: _l.append(v2) _l.append(maxKnot) if _last != True: _l.append(values[i + 1]) if insertMin and i == 0: _l.insert(0, minKnot) if postInset: vPost = _l[-1] + postInset if vPost < _l[-2]: log.debug("|{0}| >> alternate postInset".format(_str_func)) vPost = _l[-2] + postInset log.debug("|{0}| >> postInset: {1} | new: {2}".format( _str_func, _l[-1], vPost)) if len(_l) > 1: if vPost > max(_l[:-1]): log.debug( "|{0}| >> v post creater the max".format(_str_func)) _l[-1] = vPost else: _l = _l[:-1] else: _l.append(vPost) """ if _last != True: for v2 in _l: if v2 > v: _l.remove(v2)""" _l = LISTS.get_noDuplicates(_l) _l.sort() l_sets.append(_l) log.debug("|{0}| >> result: {1} | {2} | {3}".format( _str_func, i, v, _l)) l_pre = copy.copy(l_sets) #pprint.pprint(vars()) if not curvesCreate: return l_sets log.debug("|{0}| >> creating curves...".format(_str_func)) l_newCurves = [] d_curves = {} l_finalCurves = [] def getCurve(uValue, l_newCurves): _crv = d_curves.get(uValue) if _crv: return _crv _crv = mc.duplicateCurve("{0}.{1}[{2}]".format(_shape, mode, uValue), ch=0, rn=0, local=0)[0] if offset: DIST.offsetShape_byVector(_crv, offset, component='cv') d_curves[uValue] = _crv log.debug("|{0}| >> created: {1} ...".format(_str_func, _crv)) l_newCurves.append(_crv) return _crv for i, uSet in enumerate(l_sets): _loftCurves = [getCurve(uValue, l_newCurves) for uValue in uSet] """ if len(uSet)<2: l_finalCurves.append(mc.duplicate(_loftCurves[0])[0]) continue""" log.debug("|{0}| >> {1} | u's: {2}".format(_str_func, i, uSet)) """ if i == 0 and str_start: _pair = [str_start,c,l_newCurves[i+1]] else: _pair = [c,l_newCurves[i+1]]""" if len(_loftCurves) == 1: l_mainCurves = [mc.duplicate(_loftCurves[0])[0]] else: crvBase = mc.duplicate(_loftCurves[0])[0] crvEnd = mc.duplicate(_loftCurves[-1])[0] l_mainCurves = [crvBase, crvEnd] if curvesConnect: log.debug("|{0}| >> {1} | Making connectors".format( _str_func, i)) d_epPos = {} for i, crv in enumerate(_loftCurves): _l = CURVES.getUSplitList(crv, connectionPoints, rebuild=True, rebuildSpans=30)[:-1] for ii, p in enumerate(_l): if not d_epPos.get(ii): d_epPos[ii] = [] _l = d_epPos[ii] _l.append(p) for k, points in d_epPos.iteritems(): log.debug("|{0}| >> {1} | k: {1} | points: {2}".format( _str_func, k, points)) try: crv_connect = mc.curve(d=1, ep=points, os=True) #CURVES.create_fromList(posList=points) l_mainCurves.append(crv_connect) except Exception, err: print err for crv in l_mainCurves[1:]: CORERIG.shapeParent_in_place(l_mainCurves[0], crv, False) #ml_shapes.append(cgmMeta.validateObjArg(l_mainCurves[0])) l_finalCurves.append(l_mainCurves[0])
def retreive_all_data(filename): # read in the csv file pose_rig(filename) # TODO: model is posed randomly # need to extract other information like mesh info curr_data = {} connectionMap = {} anchorIndex = [] joint_dict = {} curr_data['anchorPoints'] = {} curr_data['differentialOffset'] = {} curr_data['worldPos'] = {} curr_data['worldOffset'] = {} curr_data['localOffset'] = {} curr_data['jointWorldMatrix'] = {} curr_data['jointWorldQuaternion'] = {} curr_data['jointLocalMatrix'] = {} curr_data['jointLocalQuaternion'] = {} # Read in the connection map f = open(topology_path, 'r') reader = csv.reader(f) content = list(reader) for line in content: if len(line) > 1: connectionMap[int(line[0])] = [int(c) for c in line[1:]] else: connectionMap[int(line[0])] = [] f.close() # Read in the anchor points f = open(anchor_path, 'r') reader = csv.reader(f) content = list(reader) anchorIndex = [int(line[0]) for line in content[1:]] f.close() # Read in the joint relations f = open(joint_path, 'r') reader = csv.reader(f) content = list(reader) for line in content: joint_dict[line[1]] = line[2] f.close() # Get the joint worldMatrix and worldQuaternion world_mats = {} for jnt in joint_dict: world_mat = mc.getAttr(jnt + '.worldMatrix[0]') world_mats[jnt] = world_mat wm = om.MTransformationMatrix(om.MMatrix(world_mat)) quaternion = wm.rotation(asQuaternion=True) temp = [ world_mat[0], world_mat[1], world_mat[2], world_mat[4], world_mat[5], world_mat[6], world_mat[8], world_mat[9], world_mat[10], world_mat[12], world_mat[13], world_mat[14] ] curr_data['jointWorldMatrix'][jnt] = [ round(i, PRECISION) for i in temp ] temp = [ quaternion[0], quaternion[1], quaternion[2], quaternion[3], world_mat[12], world_mat[13], world_mat[14] ] curr_data['jointWorldQuaternion'][jnt] = [ round(i, PRECISION) for i in temp ] # Get the joint local matrix and local quaternion for jnt in joint_dict: parent = joint_dict[jnt] local_mat = None if parent: parent_mat = om.MMatrix(world_mats[parent]) world_mat = om.MMatrix(world_mats[jnt]) local_mat = world_mat * parent_mat.inverse() else: local_mat = om.MMatrix(world_mats[jnt]) lm = om.MTransformationMatrix(local_mat) quaternion = lm.rotation(asQuaternion=True) temp = [ local_mat[0], local_mat[1], local_mat[2], local_mat[4], local_mat[5], local_mat[6], local_mat[8], local_mat[9], local_mat[10], local_mat[12], local_mat[13], local_mat[14] ] curr_data['jointLocalMatrix'][jnt] = [ round(i, PRECISION) for i in temp ] temp = [ quaternion[0], quaternion[1], quaternion[2], quaternion[3], local_mat[12], local_mat[13], local_mat[14] ] curr_data['jointLocalQuaternion'][jnt] = [ round(i, PRECISION) for i in temp ] # Get the mesh vertex world information throuth following steps meshShape, positions, curr_data['worldPos'] = get_worldPos(MESH, PRECISION) # Create a duplicate duplicate = mc.duplicate(MESH, name=MESH + 'Dup', upstreamNodes=False, returnRootsOnly=True)[0] # Create deformers deformers = prep_mesh(MESH) deformer_env_dict = {} # shutdown all deformers except for skin clusters for deformer in deformers: dtype = mc.nodeType(deformer) if dtype not in SKIN_TYPES: deformer_env_dict[deformer] = mc.getAttr(deformer + '.envelope') mc.setAttr(deformer + '.envelope', 0.0) # Get mesh linear postions linear_pos, curr_data['worldOffset'] = get_worldOffset( MESH, PRECISION, meshShape, positions) # Get local offset before linear skin blending offsets = get_localOffset(MESH, duplicate, TEMP_BS_NODE, TEMP_TARGET) vertex_count = len(curr_data['worldPos']) for i in range(vertex_count): offset = offsets.get(i, [0.0, 0.0, 0.0]) curr_data['localOffset'][i] = [ round(data, PRECISION) for data in offset ] # Generate the differential offset data for i in range(len(connectionMap)): neighbors = connectionMap[i] valence = float(len(neighbors)) new_coord = offsets.get(i, [0.0, 0.0, 0.0]) neighbor_values = [0.0, 0.0, 0.0] for neighbor in neighbors: nb_coord = offsets.get(neighbor, [0.0, 0.0, 0.0]) neighbor_values[0] += nb_coord[0] neighbor_values[1] += nb_coord[1] neighbor_values[2] += nb_coord[2] x = new_coord[0] - neighbor_values[0] / valence y = new_coord[1] - neighbor_values[1] / valence z = new_coord[2] - neighbor_values[2] / valence offset = [x, y, z] curr_data['differentialOffset'][i] = [ round(data, PRECISION) for data in offset ] # Get the anchor points data for anchor in anchorIndex: offset = offsets.get(anchor, [0.0, 0.0, 0.0]) curr_data['anchorPoints'][anchor] = [ round(data, PRECISION) for data in offset ] # Restore the rig for deformer in deformers: dtype = mc.nodeType(deformer) if dtype not in SKIN_TYPES: mc.setAttr(deformer + '.envelope', deformer_env_dict[deformer]) mc.delete(duplicate) retreive_data(curr_data, filename)
def invert(base=None, corrective=None, progressBar=None, name=None): if not cmds.pluginInfo('cvShapeInverter.py', query=True, loaded=True): cmds.loadPlugin('%s/cvShapeInverter.py' % scriptTool.getScriptPath()) # end if cmds.undoInfo(openChunk=True) if not base or not corrective: sel = cmds.ls(sl=True) if not sel or len(sel) != 2: cmds.undoInfo(closeChunk=True) raise RuntimeError, 'Select base then corrective' # end if base, corrective = sel # end if # Get points on base mesh basePoints = getPoints(base) numPoints = basePoints.length() # Get points on corrective mesh correctivePoints = getPoints(corrective) # Get the intermediate mesh shapes = cmds.listRelatives(base, children=True, shapes=True, path=True) for s in shapes: if cmds.getAttr('%s.intermediateObject' % s) and cmds.listConnections( '%s.worldMesh' % s, source=False): origMesh = s break # end if else: cmds.undoInfo(closeChunk=True) raise RuntimeError('No intermediate shape found for %s.' % base) # end for # Get the component offset axes origPoints = getPoints(origMesh) xPoints = OpenMaya.MPointArray(origPoints) yPoints = OpenMaya.MPointArray(origPoints) zPoints = OpenMaya.MPointArray(origPoints) for i in range(numPoints): xPoints[i].x += 1.0 yPoints[i].y += 1.0 zPoints[i].z += 1.0 # end for setPoints(origMesh, xPoints) xPoints = getPoints(base) setPoints(origMesh, yPoints) yPoints = getPoints(base) setPoints(origMesh, zPoints) zPoints = getPoints(base) setPoints(origMesh, origPoints) # Create the mesh to get the inversion deformer if not name: name = '%s_inverted' % corrective # end if invertedShape = cmds.duplicate(base, name=name)[0] # Delete the unnessary shapes shapes = cmds.listRelatives(invertedShape, children=True, shapes=True) for s in shapes: if cmds.getAttr('%s.intermediateObject' % s): cmds.delete(s) # end if # end for setPoints(invertedShape, origPoints) # Unlock the transformation attrs for attr in 'trs': for x in 'xyz': cmds.setAttr('%s.%s%s' % (invertedShape, attr, x), lock=False) # end for # end for cmds.setAttr('%s.visibility' % invertedShape, 1) deformer = cmds.deformer(invertedShape, type='cvShapeInverter')[0] # Calculate the inversion matrices if progressBar: progressBar.setMaximum(numPoints) oDeformer = getMObject(deformer) fnDeformer = OpenMaya.MFnDependencyNode(oDeformer) plugMatrix = fnDeformer.findPlug('inversionMatrix', False) fnMatrixData = OpenMaya.MFnMatrixData() for i in range(numPoints): matrix = OpenMaya.MMatrix() setMatrixRow(matrix, xPoints[i] - basePoints[i], 0) setMatrixRow(matrix, yPoints[i] - basePoints[i], 1) setMatrixRow(matrix, zPoints[i] - basePoints[i], 2) matrix = matrix.inverse() oMatrix = fnMatrixData.create(matrix) plugMatrixElement = plugMatrix.elementByLogicalIndex(i) plugMatrixElement.setMObject(oMatrix) if progressBar: progressBar.setValue(i) if progressBar: progressBar.setMinimum(0) progressBar.setValue(0) progressBar.setMaximum(1) # end for # Store the base points. fnPointData = OpenMaya.MFnPointArrayData() oPointData = fnPointData.create(basePoints) plugDeformedPoints = fnDeformer.findPlug('deformedPoints', False) plugDeformedPoints.setMObject(oPointData) cmds.connectAttr('%s.outMesh' % getShape(corrective), '%s.correctiveMesh' % deformer) cmds.setAttr('%s.activate' % deformer, True) cmds.undoInfo(closeChunk=True) return invertedShape
def execute(*args): mySel = cmds.ls(sl=True) D = cmds.intFieldGrp(Density, q=True, value1=True) angle = cmds.intFieldGrp(Angle, q=True, value1=True) if D > 100: D = 100 if D < 0: D = 0 clonedItems = [] startingPointItem = mySel[0] endingPointItem = mySel[1] startingPoint = cmds.objectCenter(mySel[0]) endingPoint = cmds.objectCenter(mySel[1]) #This ensure that the starting point is always the highest object selected if startingPoint[1] < endingPoint[1]: temp = startingPointItem startingPointItem = endingPointItem endingPointItem = temp startingPoint = cmds.objectCenter(startingPointItem) endingPoint = cmds.objectCenter(endingPointItem) time = 0 distance = math.sqrt(((endingPoint[0] - startingPoint[0])**2) + (endingPoint[2] - startingPoint[2])**2) initialSpeed = (distance / math.cos(math.radians(angle))) * math.sqrt( 9.8 / (2 * distance * math.tan(math.radians(angle)) + 2 * startingPoint[1])) flightTime = distance / (initialSpeed * math.cos(math.radians(angle))) print "START HEIGHT: ", math.sin(math.radians(2 * angle)) print "DISTANCE: ", distance print "SPEED: ", initialSpeed print "TIME: ", flightTime print distance deltaX = endingPoint[0] - startingPoint[0] deltaZ = endingPoint[2] - startingPoint[2] if deltaZ != 0: directionAngle = math.atan(deltaX / deltaZ) else: if deltaX > 0: directionAngle = (math.pi) / 2 else: directionAngle = (-math.pi) / 2 print "Angle2: ", directionAngle if deltaX < 0 and deltaZ < 0: directionAngle = directionAngle + math.pi elif deltaX >= 0 and deltaZ < 0: directionAngle = directionAngle + math.pi while time <= flightTime: newClone = cmds.duplicate(startingPointItem) x = startingPoint[0] + initialSpeed * math.cos( math.radians(angle)) * math.sin(directionAngle) * time y = -0.5 * 9.8 * (time**2) + initialSpeed * math.sin( math.radians(angle)) * time + startingPoint[1] z = startingPoint[2] + initialSpeed * math.cos( math.radians(angle)) * math.cos(directionAngle) * time print "time: ", time print "X: ", x, "Y: ", y, "Z: ", z cmds.move(x, y, z, newClone, absolute=True) time = time + 0.3
def processGroup(self, group, parent): import System.groupSelected as groupSelected reload(groupSelected) tempGroup = cmds.duplicate(group, parentOnly=True, inputConnections=True)[0] emptyGroup = cmds.group(empty=True) cmds.parent(tempGroup, emptyGroup, absolute=True) scaleAxis = ".scaleX" if self.mirrorPlane == "XZ": scaleAxis = ".scaleY" elif self.mirrorPlane == "XY": scaleAxis = ".scaleZ" cmds.setAttr(emptyGroup + scaleAxis, -1) instance = groupSelected.GroupSelected() groupSuffix = group.partition("__")[2] #all partitions __ not more 2 newGroup = instance.createGroupAtSpecified(groupSuffix + "_mirror", tempGroup, parent) cmds.lockNode("Group__container", lock=False, lockUnpublished=False) cmds.delete(emptyGroup) for moduleLink in ((group, newGroup), (newGroup, group)): attributeValue = moduleLink[1] + "__" if self.mirrorPlane == "YZ": attributeValue += "X" elif self.mirrorPlane == "XZ": attributeValue += "Y" elif self.mirrorPlane == "XY": attributeValue += "Z" cmds.select(moduleLink[0]) cmds.addAttr(dt="string", longName="mirrorLinks", k=False) cmds.setAttr(moduleLink[0] + ".mirrorLinks", attributeValue, type="string") cmds.select(clear=True) children = cmds.listRelatives(group, children=True) children = cmds.ls(children, transforms=True) #85 for child in children: if child.find("Group__") == 0: self.processGroup(child, newGroup) else: childNamespaces = utils.stripAllNamespaces(child) if childNamespaces != None and childNamespaces[ 1] == "module_transform": for module in self.moduleInfo: if childNamespaces[0] == module[0]: moduleContainer = module[1] + ":module_container" cmds.lockNode(moduleContainer, lock=False, lockUnpublished=False) moduleTransform = module[1] + ":module_transform" cmds.parent(moduleTransform, newGroup, absolute=True) cmds.lockNode(moduleContainer, lock=True, lockUnpublished=True)
def freezeCombo(combo): """ Freeze a combo so you can change the upstream combos and shapes without affecting the result that you sculpted for the given combo In practice, this snapshots the combo, then live-reads the upstream shapes from the main blendshape and builds an up-to-date combo. The difference between these two meshes is added back into the combo shape """ simplex = combo.simplex tweakShapeGroups = [] fullGeos = [] ppFilter = [] # disconnect the controller from the operator with disconnected(simplex.DCC.op) as sliderCnx: for shapeIdx, pp in enumerate(combo.prog.pairs): tVal = pp.value freezeShape = pp.shape if freezeShape.isRest: continue # zero all the sliders cnx = sliderCnx[simplex.DCC.op] for a in cnx.itervalues(): cmds.setAttr(a, 0.0) # set the combo values for pair in combo.pairs: cmds.setAttr(cnx[pair.slider.thing], pair.value * tVal) tweakPairs = [] for shape in simplex.shapes[1:]: # skip the restShape shapeVal = cmds.getAttr(shape.thing) if abs(shapeVal) > 0.0001: tweakPairs.append((shape, shapeVal)) # Extract this fully-on shape fullGeo = cmds.duplicate( simplex.DCC.mesh, name="{0}_Freeze".format(freezeShape.name) )[0] fullGeos.append(fullGeo) # Clean any orig shapes for now interObjs = cmds.ls( cmds.listRelatives(fullGeo, shapes=True), intermediateObjects=True ) cmds.delete(interObjs) tweakShapeGroups.append(tweakPairs) ppFilter.append(pp) simplex.DCC.primeShapes(combo) shapePlugFmt = ( ".inputTarget[{meshIdx}].inputTargetGroup[{shapeIdx}].inputTargetItem[6000]" ) endPlugs = [ ".inputRelativePointsTarget", ".inputRelativeComponentsTarget", ".inputPointsTarget", ".inputComponentsTarget", "", ] shapeNode = simplex.DCC.shapeNode helpers = [] for geo, tweakPairs, pp in zip(fullGeos, tweakShapeGroups, ppFilter): # build the basicBS node bbs = cmds.deformer(geo, type="basicBlendShape")[0] helpers.append(bbs) idx = 0 for shape, val in tweakPairs: if shape == freezeShape: continue # connect the output shape.thing to the basicBS # Create an empty shape. Do it like this to get the automated renaming stuff gDup = cmds.duplicate(geo, name="{0}_DeltaCnx".format(shape.name))[0] # The 4th value must be 1.0 so the blendshape auto-names cmds.blendShape(bbs, edit=True, target=(geo, idx, gDup, 1.0)) cmds.blendShape(bbs, edit=True, weight=(idx, -val)) cmds.delete(gDup) # Connect the shape plugs inPlug = bbs + shapePlugFmt inPlug = inPlug.format(meshIdx=0, shapeIdx=idx) shapeIdx = simplex.DCC.getShapeIndex(shape) outPlug = shapeNode + shapePlugFmt outPlug = outPlug.format(meshIdx=0, shapeIdx=shapeIdx) # Must connect the individual child plugs rather than the top # because otherwise the input geometry plug overrides these deltas for ep in endPlugs: cmds.connectAttr(outPlug + ep, inPlug + ep) idx += 1 # Connect the basicBS back into freezeShape freezeShapeIdx = simplex.DCC.getShapeIndex(pp.shape) freezeShapeTarget = shapeNode + shapePlugFmt + ".inputGeomTarget" freezeShapeTarget = freezeShapeTarget.format(meshIdx=0, shapeIdx=freezeShapeIdx) cmds.connectAttr(geo + ".outMesh", freezeShapeTarget) gShapes = cmds.listRelatives(geo, shapes=True) if True: # Hide the frozen shapenode under the ctrl as an intermediate shape for gs in gShapes: cmds.setAttr(gs + ".intermediateObject", 1) nn = cmds.parent(gs, simplex.DCC.ctrl, shape=True, relative=True) helpers.extend(nn) # Get rid of the extra transform object cmds.delete(geo) else: helpers.extend(cmds.listRelatives(geo, shapes=True)) # keep track of the shapes under the ctrl object combo.freezeThing = helpers
def doSDKs(SDKnodes, target, search, replace, i, iterExec, specialIter, SDKResults, BWNResults, mode, createDriverAttr, drAttrSearch, drAttrReplace): ''' This is the procedure that actually performs the SDK replication ''' # Declare search direction of connectionInfo command, based of tool mode. if mode: conInfoLambda = lambda node: cmds.listConnections( '%s.input' % node[0], d=False, s=True, p=True, scn=True) else: conInfoLambda = lambda node: cmds.listConnections( '%s.output' % node[0], d=True, s=False, p=True, scn=True) for node in SDKnodes: # Check what's connected to SDK nodes and see if the target nodes # have the same attributes as the source node, if no reults or # no matching attributes, continue. connections = conInfoLambda(node) if not connections or ( not createDriverAttr and (not cmds.attributeQuery( node[1].replace(drAttrSearch, drAttrReplace), node=target, ex=True) and not cmds.attributeQuery( node[1].split('[')[0].replace(drAttrSearch, drAttrReplace), node=target, ex=True))): print 'CONTINUED', node # delete me continue # If createDriverAttr is set to True and the driver attribute # doesn't exist, try to create it on the new driver. elif (not cmds.attributeQuery( node[1].replace(drAttrSearch, drAttrReplace), node=target, ex=True) and not cmds.attributeQuery(node[1].split('[')[0].replace( drAttrSearch, drAttrReplace), node=target, ex=True)): if mode or not createDriverAttr: continue sourceDriver = cmds.listConnections('%s.input' % node[0], d=False, s=True, p=False, scn=True)[0] createDriverAttrFunc(sourceDriver, target, node[1].split('[')[0], drAttrSearch, drAttrReplace) if isinstance(connections, str): connections = [connections] # Duplicate keyframe node and mirror if asked. newKeyNode = cmds.duplicate(node[0])[0] if node[2]: mirrorKeys(newKeyNode) # Go through all the connections. for curNode in connections: # If in driver mode, check to see if node connected to keyframe # is a blendWeighted node. origBW = '' if not mode: nodeType = cmds.ls(curNode.split('.')[0], st=True)[1] if nodeType == 'blendWeighted': origBW = curNode connections2 = cmds.listConnections('%s.output' % curNode.split('.')[0], d=True, s=False, p=True, scn=True) else: connections2 = [curNode] else: connections2 = [curNode] # Connect the duplicated keyframes # to their respective target connections. for curNode2 in connections2: if search or not mode: # regex search pattern section. curRegexer = re.search(search, curNode2) errorCheck = False print(replace, iterExec, curNode, curNode2, mode, newKeyNode, origBW) # delete me if hasattr(curRegexer, 'group'): repPattern = curRegexer.group(0) if repPattern: (errorCheck, newConn) = \ connectToConn(replace, iterExec, curNode, curNode2, repPattern, mode, newKeyNode, origBW) else: errorCheck = True else: errorCheck = True if errorCheck: if mode: print( '\nFailure to find a driver for node %s ' 'based on search criteria %s for driver node %s .' % (target, search, curNode2.split('.')[0])) cmds.delete(newKeyNode) else: print( '\nFailure to find a driven for nodes %s ' 'based on search criteria %s for driven node %s .' % (target, search, curNode2.split('.')[0])) continue elif mode: cmds.connectAttr(curNode2, '%s.input' % newKeyNode, f=True) newConn = curNode2 # Connect the new SDK's to the new driver attrs. if mode: cmds.connectAttr('%s.output' % newKeyNode, '%s.%s' % (target, node[1]), f=True) else: cmds.connectAttr( '%s.%s' % (target, node[1].replace(drAttrSearch, drAttrReplace)), '%s.input' % newKeyNode, f=True) SDKResults.append( 'Connected Driver node %s.%s.output to ' 'Driven node %s.%s .' % (newConn, '.'.join( curNode2.split('.')[1:]), target, node[1]))
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 0: for axis in self.mirrorAxis: gotValue = cmds.getAttr( side + self.userGuideName + "_Guide_Base.translate" + axis) flipedValue = gotValue * (-2) cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.translate' + axis, flipedValue) else: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) #for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp" # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.base = side + self.userGuideName + '_Guide_Base' cmds.select(clear=True) # declare guide: self.guide = side + self.userGuideName + "_Guide_JointLoc1" self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" self.radiusGuide = side + self.userGuideName + "_Guide_Base_RadiusCtrl" # create a joint: self.jnt = cmds.joint(name=side + self.userGuideName + "_Jnt", scaleCompensate=False) cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False) utils.setJointLabel(self.jnt, s + jointLabelAdd, 18, self.userGuideName) # create a control: if not self.getHasIndirectSkin(): if self.curveDegree == 0: self.curveDegree = 1 # work with curve shape and rotation cases: indirectSkinRot = (0, 0, 0) if self.langDic[ self.langName]['c058_main'] in self.userGuideName: ctrlTypeID = "id_054_SingleMain" if len(sideList) > 1: if self.langDic[self.langName][ 'c041_eyebrow'] in self.userGuideName: indirectSkinRot = (0, 0, -90) else: indirectSkinRot = (0, 0, 90) else: ctrlTypeID = "id_029_SingleIndSkin" if self.langDic[ self.langName]['c045_lower'] in self.userGuideName: indirectSkinRot = (0, 0, 180) elif self.langDic[self.langName][ 'c043_corner'] in self.userGuideName: if "00" in self.userGuideName: indirectSkinRot = (0, 0, 90) else: indirectSkinRot = (0, 0, -90) self.singleCtrl = self.ctrls.cvControl( ctrlTypeID, side + self.userGuideName + "_Ctrl", r=self.ctrlRadius, d=self.curveDegree, rot=indirectSkinRot) utils.originedFrom(objName=self.singleCtrl, attrString=self.base + ";" + self.guide + ";" + self.cvEndJoint + ";" + self.radiusGuide) # position and orientation of joint and control: cmds.delete( cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False)) cmds.delete( cmds.parentConstraint(self.guide, self.singleCtrl, maintainOffset=False)) # zeroOut controls: zeroOutCtrlGrp = utils.zeroOut([self.singleCtrl], offset=True)[0] # hide visibility attribute: cmds.setAttr(self.singleCtrl + '.visibility', keyable=False) # fixing flip mirror: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(zeroOutCtrlGrp + ".scaleX", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleY", -1) cmds.setAttr(zeroOutCtrlGrp + ".scaleZ", -1) if not self.getHasIndirectSkin(): cmds.addAttr(self.singleCtrl, longName='scaleCompensate', attributeType="bool", keyable=False) cmds.setAttr(self.singleCtrl + ".scaleCompensate", 1, channelBox=True) cmds.connectAttr(self.singleCtrl + ".scaleCompensate", self.jnt + ".segmentScaleCompensate", force=True) if self.getHasIndirectSkin(): # create fatherJoints in order to zeroOut the skinning joint: cmds.select(clear=True) jxtName = self.jnt.replace("_Jnt", "_Jxt") jxt = cmds.duplicate(self.jnt, name=jxtName)[0] utils.clearDpArAttr([jxt]) cmds.makeIdentity(self.jnt, apply=True, jointOrient=False) cmds.parent(self.jnt, jxt) attrList = [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ] for attr in attrList: cmds.connectAttr(self.singleCtrl + '.' + attr, self.jnt + '.' + attr) if self.getHasHolder(): cmds.delete(self.singleCtrl + "0Shape", shape=True) self.singleCtrl = cmds.rename( self.singleCtrl, self.singleCtrl + "_" + self.langDic[self.langName]['c046_holder'] + "_Grp") self.ctrls.setLockHide([self.singleCtrl], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ]) self.jnt = cmds.rename( self.jnt, self.jnt.replace( "_Jnt", "_" + self.langDic[self.langName]['c046_holder'] + "_Jis")) self.ctrls.setLockHide([self.jnt], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ], True, True) else: if self.getHasSDKLocator(): if not self.langDic[self.langName][ 'c058_main'] in self.userGuideName: # this one will be used to receive inputs from sdk locator: sdkJisName = self.jnt.replace( "_Jnt", "_SDK_Jis") sdkJis = cmds.duplicate(self.jnt, name=sdkJisName)[0] # sdk locator: sdkLoc = cmds.spaceLocator( name=sdkJis.replace("_Jis", "_Loc"))[0] sdkLocGrp = cmds.group(sdkLoc, name=sdkLoc + "_Grp") cmds.delete( cmds.parentConstraint( self.singleCtrl, sdkLocGrp, maintainOffset=False)) cmds.parent(sdkLocGrp, self.singleCtrl, relative=True) sdkLocMD = cmds.createNode("multiplyDivide", name=sdkLoc + "_MD") cmds.addAttr(sdkLoc, longName="intensityX", attributeType="float", defaultValue=-1, keyable=False) cmds.addAttr(sdkLoc, longName="intensityY", attributeType="float", defaultValue=-1, keyable=False) cmds.addAttr(sdkLoc, longName="intensityZ", attributeType="float", defaultValue=-1, keyable=False) cmds.connectAttr(sdkLoc + ".translateX", sdkLocMD + ".input1X", force=True) cmds.connectAttr(sdkLoc + ".translateY", sdkLocMD + ".input1Y", force=True) cmds.connectAttr(sdkLoc + ".translateZ", sdkLocMD + ".input1Z", force=True) cmds.connectAttr(sdkLoc + ".intensityX", sdkLocMD + ".input2X", force=True) cmds.connectAttr(sdkLoc + ".intensityY", sdkLocMD + ".input2Y", force=True) cmds.connectAttr(sdkLoc + ".intensityZ", sdkLocMD + ".input2Z", force=True) cmds.connectAttr(sdkLocMD + ".outputX", sdkLocGrp + ".translateX", force=True) cmds.connectAttr(sdkLocMD + ".outputY", sdkLocGrp + ".translateY", force=True) cmds.connectAttr(sdkLocMD + ".outputZ", sdkLocGrp + ".translateZ", force=True) cmds.addAttr(self.singleCtrl, longName="displayLocator", attributeType="bool", keyable=False) cmds.setAttr(self.singleCtrl + ".displayLocator", 0, channelBox=True) cmds.connectAttr(self.singleCtrl + ".displayLocator", sdkLoc + ".visibility", force=True) cmds.setAttr(sdkLoc + ".visibility", lock=True) for attr in attrList: cmds.connectAttr(sdkLoc + '.' + attr, sdkJis + '.' + attr) cmds.setAttr(sdkLocGrp + ".rotateX", 0) cmds.setAttr(sdkLocGrp + ".rotateY", 0) cmds.setAttr(sdkLocGrp + ".rotateZ", 0) # rename indirectSkinning joint from Jnt to Jis: self.jnt = cmds.rename( self.jnt, self.jnt.replace("_Jnt", "_Jis")) # fix mirror issue: if s == 1: if cmds.getAttr(self.moduleGrp + ".flip") == 1: cmds.setAttr(jxt + ".scaleX", -1) cmds.setAttr(jxt + ".scaleY", -1) cmds.setAttr(jxt + ".scaleZ", -1) else: # like a fkLine # create parentConstraint from ctrl to jnt: cmds.parentConstraint(self.singleCtrl, self.jnt, maintainOffset=False, name=self.jnt + "_PaC") # create scaleConstraint from ctrl to jnt: cmds.scaleConstraint(self.singleCtrl, self.jnt, maintainOffset=True, name=self.jnt + "_ScC") # create end joint: cmds.select(self.jnt) self.endJoint = cmds.joint(name=side + self.userGuideName + "_JEnd", radius=0.5) cmds.delete( cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)) self.mainJisList.append(self.jnt) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( side + self.userGuideName + "_Ctrl_Zero_0_Grp", name=side + self.userGuideName + "_Control_Grp") if self.getHasIndirectSkin(): locScale = cmds.spaceLocator( name=side + self.userGuideName + "_Scalable_DO_NOT_DELETE_PLEASE_Loc")[0] cmds.setAttr(locScale + ".visibility", 0) self.toScalableHookGrp = cmds.group( locScale, name=side + self.userGuideName + "_IndirectSkin_Grp") jxtGrp = cmds.group(side + self.userGuideName + "_Jxt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group( jxtGrp, self.toScalableHookGrp, self.toCtrlHookGrp, name=side + self.userGuideName + "_Grp") else: self.toScalableHookGrp = cmds.group( side + self.userGuideName + "_Jnt", name=side + self.userGuideName + "_Joint_Grp") self.toStaticHookGrp = cmds.group( self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") # create a locator in order to avoid delete static or scalable group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE_PLEASE_Loc")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) self.ctrls.setLockHide([loc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") self.aStaticGrpList.append(self.toStaticHookGrp) self.aCtrlGrpList.append(self.toCtrlHookGrp) # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # check mirror indirectSkin bug in Maya2018: if (int(cmds.about(version=True)[:4]) == 2018): if self.mirrorAxis != 'off': if self.getHasIndirectSkin(): meshList = cmds.ls(selection=False, type="mesh") if meshList: self.detectedBug = True # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def copySDK(curAttrs=[], mirrorAttrs=[], source='', targets=[], search='', replace='', specialIter=[], sort=False, mode='driven', drAttrSearch='', drAttrReplace='', createDriverAttr=False): '''This definition is used to copy SDK setups from one node to another node/s in Maya. With no declarations, the script works by getting the selection list. The first selected object is the source, everything else is a target. The script will copy SDKs from the source and replicate it on the targets. SDKs will be linked to the original source driver by default. Node and attribute options curAttrs - string or string list - is for explicitly declaring which attributes to copy SDKs from. If you don't declare it, the script will search for SDKs on all keyable attributes of the source. mirrorAttrs - string or string list - is to tell the script which attributes on the source object will receive a negative value in their keyframes. source - string - is to explicitly declare the source node to copy. If this is declared, targets must also be declared. If not declared, the selection list is used and the first selected object is the source. - if mode is set to driven, source represents the source driven node, when mode is set to driver, source represents the source driver node. targets - string or string list - is to explicitly declare target nodes to apply SDKs to. If this is declared, source must also be declared. If not declared, the selection list is used and all other objects other than the first comprise the targets list. - if mode is set to driven, targets represents the destination driven node/s, when mode is set to driver, targets represents the destination driver node/s. String search options for driver nodes: search - string - when mode is set to Driven, is used for pattern searching in Driver names. search and replace both have to be declared. If not declared, the SDK's are connected to the original driver node attributes. This attribute accepts regex search strings. - when mode is set to Driver, this is used instead to search for Driven object names. search and replace MUST be declared in case of Driver-centric operations. replace - string - when mode is set to Driven, is used for pattern searching in Driver names, to look for alternate Driver nodes. This provides the replace string to use when looking for Driver nodes. The replace string can use the special %s character to provide more flexibility with choosing different Drivers for multiple Driven nodes. - when mode is set to Driver, this is used instead to search for Driven object names. search and replace MUST be declared in case of Driver-centric operations. specialIter - int or string list or list of lists - is used when you want to provide a list or an iteratable object to use when you want more flexibility in naming your driver object. Your replace variable must contain a replace string with %s, and that will get swapped by what you enter here. - You can use a single list ['a', 'b', 'c'], lists within lists for multiple %s's [['a', 'b', 'c'], [1, 2, 3]], or python techniques such as range e.g., range(0,12). - The only rule is that the lists have to be as long as the number of targets. sort - boolean - Sort the target list alphabetically. Helps to reorganize the targets list if you're using the specialIter function. mode - string 'driver', 'driven' or 'guess' - Decides whether the script operates via selecting a driven node, or a driver node. Default is set to driven, meaning you have to select the driven object you want to mirror over as your first selection. Options are either 'driver', 'driven', or 'guess' (if set to guess, will find whether it has more outgoing or incomming sdk keyframes), and the default is driven. - In driven mode, script wil find the original driver from the driven node and seek out alternate driver names via the search and replace variables if declared, else it will use the original driver/s. - In driver mode, script will seek out all driven nodes and search for the alternate driven node names based off the search and replace variables. In driver mode, search and replace declaration is required. drAttrSearch - string - If declared, search for this string component in a source driver attribute, for the purpose of replacing this string in a target driver attribute. drAttrReplace - string - If declared, use this string to replace a found attrSearch component in a source driver attr when looking for a target driver attr. createDriverAttr - boolean - Create the driver attribute on a found target node if it did not already exist, Default is False. This only works in 'driver' mode. ''' # Make sure all variables are correct if not source.strip() or not targets: curlist = cmds.ls(sl=True, ap=True) if not curlist or len(curlist) < 2: print('\nPlease select at least two objects.') return 1 source = curlist[0] targets = curlist[1:] elif isinstance(targets, str) and targets.strip(): targets = [targets] if sort: targets.sort() if curAttrs: if isinstance(curAttrs, str) and curAttrs.strip(): curAttrs = [curAttrs] attrs = [ cmds.attributeQuery(x, node=source, ln=True) for x in curAttrs if cmds.attributeQuery(x, node=source, ex=True) ] if not attrs: print('Specified attributes %s, do not exist on driver %s .' % (', '.join(attrs), source)) return 1 else: attrs = cmds.listAttr(source, k=True) if mirrorAttrs: if isinstance(mirrorAttrs, str): mirrorAttrs = [mirrorAttrs] tempMirrorAttrs = [] for attr in mirrorAttrs: if not cmds.attributeQuery(attr, node=source, ex=True): continue tempMirrorAttrs.append( cmds.attributeQuery(attr, node=source, ln=True)) tempMirrorAttrs = list(set(tempMirrorAttrs)) if tempMirrorAttrs: mirrorAttrs = tempMirrorAttrs else: print( 'Specified attributes to be mirrored %s, do not exist ' 'on source node %s .' % (', '.join(mirrorAttrs), source)) mirrorAttrs = [] if mode.strip().lower() == 'driven': mode = True elif mode.strip().lower() == 'driver': mode = False elif mode.lower() == 'guess': driverNodes = [] drivenNodes = [] drivenNodes, blendWeightedNodes = \ findSDKNodes(mirrorAttrs, source, attrs, True) if blendWeightedNodes: for node in blendWeightedNodes: SDKN2, SKN, ON = searchBWNodes(node) if SDKN2: a = set(drivenNodes + SDKN2) drivenNodes = list(a) driverNodes, blendWeightedNodes = \ findSDKNodes(mirrorAttrs, source, attrs, False) if len(drivenNodes) >= len(driverNodes): mode = True else: mode = False else: print('\nUnrecognized mode argument: "' + str(mode) + '", use either "driver", "driven", or "guess".') return 1 # Determine special iteration parameters if there is a %s in the replace # variable. Used for complex Driver name searching, if each of your targets # has a different driver object. SDKResults = [] BWNResults = [] iterExec = None if (not search or not replace) and mode: search = None replace = None elif (not search or not replace) and not mode: print( '\nPlease "declare" search and "replace" variables ' 'when in driver mode.') return 1 elif replace.count('%s') and not specialIter: print( '\nWhen using the "%s" character, you must declare ' 'a specialIter list') return 1 elif replace.count('%s'): if (isinstance(specialIter[0], list) or isinstance(specialIter[0], tuple)): numArgs = len(specialIter) iterExec = 'feeder = (' iterScratch = [] for x in range(0, numArgs): if len(specialIter[x]) != len(targets): print('\nspecialIter item ' + str(x) + ' length (' + str(len(specialIter[x])) + ') must be the same as target' ' length (' + str(len(targets)) + ') .') return 1 iterScratch.append('specialIter[%s][i]' % str(x)) iterExec += ', '.join(iterScratch) + ' )' else: if len(specialIter) != len(targets): print('\nspecialIter length (' + str(len(specialIter)) + ') must be the same as target length (' + str(len(targets)) + ') .') return 1 iterExec = 'feeder = specialIter[i]' # Acquire SDK and blendweighted nodes from source SDKnodes, blendWeightedNodes = \ findSDKNodes(mirrorAttrs, source, attrs, mode) # Go through all the targets and mirror SDK nodes and # blendWeighted nodes with SDK from source. i = 0 for target in targets: if SDKnodes: doSDKs(SDKnodes, target, search, replace, i, iterExec, specialIter, SDKResults, BWNResults, mode, createDriverAttr, drAttrSearch, drAttrReplace) if blendWeightedNodes and mode: for node in blendWeightedNodes: SDKnodes2, SKnodes, otherNodes = searchBWNodes(node) if SDKnodes2: newBlendNode = cmds.duplicate(node[0])[0] doSDKs(SDKnodes2, newBlendNode, search, replace, i, iterExec, specialIter, SDKResults, BWNResults, True, createDriverAttr, drAttrSearch, drAttrReplace) if SKnodes: for node2 in SKnodes: newKeyNode = cmds.duplicate(node2[0])[0] if node2[2]: mirrorKeys(newKeyNode) cmds.connectAttr('%s.output' % newKeyNode, '%s.%s' % (newBlendNode, node2[1]), f=True) cmds.connectAttr('%s.output' % newBlendNode, '%s.%s' % (target, node[1]), f=True) BWNResults.append('Connected Blend Weighted node ' '%s.output to Driven node %s.%s' % (newBlendNode, target, node[1])) else: print('\nNo SDK nodes connected to blendWeighted node ' + node[0] + ', skipping...') i += 1 return 0
def createWheel(): # query UI choice createTire = cmds.radioButtonGrp('wheelTire', q=True, sl=True) createHub = cmds.radioButtonGrp('wheelHub', q=True, sl=True) # create a tire if (createTire == 1): # name nsTmp = "Tire" + str(rnd.randint(1000, 9999)) cmds.select(clear=True) cmds.namespace(add=nsTmp) cmds.namespace(set=nsTmp) # query colour from UI rgb = cmds.colorSliderGrp('tireColour', q=True, rgbValue=True) # create cylinder for the base tire = cmds.polyCylinder(r=3.5, h=3.5, sx=36) # add a smaller sphere to round up the tire tmp = cmds.polySphere(r=3.35, sy=15, sx=36) cmds.scale(1.1, scaleY=True) # remove non intersecting parts tire = cmds.polyCBoolOp(tire, tmp, op=3, ch=False) # Add texture: # create cylinder as the base for texture at 1 side texture1 = cmds.polyCylinder(r=2.8, h=1.75, sx=36) # move it up cmds.move(1.75 / 2, moveY=True, a=True) # in range of subdivisions for i in range(35): #for all even numbers if (i % 2 == 0): cmds.select(texture1[0] + ".f[" + str(i) + "]") # local translate on Z and scale x cmds.polyExtrudeFacet(ltz=1, lsx=1.35) # duplicate texture 1 for the 2nd side texture2 = cmds.duplicate(texture1) cmds.select(texture2) cmds.move(-1.75 / 2, moveY=True, a=True) cmds.rotate(10, rotateY=True, a=True) # combine textures 1 and 2 texture = cmds.polyCBoolOp(texture1, texture2, op=1, ch=False) # add a smaller sphere to round up the texture tmp = cmds.polySphere(r=3.7, sy=13, sx=36) # remove non intersecting parts texture = cmds.polyCBoolOp(texture, tmp, op=3, ch=False) cmds.polyMergeVertex(d=0.05, ch=False) # create another cylinder for the hole tmp = cmds.polyCylinder(r=2, h=3.5) # remove it tire = cmds.polyCBoolOp(tire, tmp, op=2, ch=False) tmp = cmds.polyCylinder(r=2, h=3.5) texture = cmds.polyCBoolOp(texture, tmp, op=2, ch=False) # add material myShader = cmds.shadingNode('lambert', asShader=True, name="blckMat") cmds.setAttr(nsTmp + ":blckMat.color", rgb[0], rgb[1], rgb[2], type='double3') cmds.polyUnite((nsTmp + ":*"), n=nsTmp, ch=False) cmds.rotate(90, rotateX=True, a=True) cmds.rotate(90, rotateY=True, a=True) cmds.move(3.466, moveY=True, a=True) cmds.delete(ch=True) cmds.hyperShade(assign=(nsTmp + ":blckMat")) cmds.namespace(removeNamespace=":" + nsTmp, mergeNamespaceWithParent=True) # create a hub if (createHub == 1): # name nsTmp = "Hub" + str(rnd.randint(1000, 9999)) cmds.select(clear=True) cmds.namespace(add=nsTmp) cmds.namespace(set=nsTmp) # query colour from UI rgb = cmds.colorSliderGrp('hubColour', q=True, rgbValue=True) # base hub = cmds.polyCylinder(r=2.1, h=2.8) # outline tmp = cmds.polyCylinder(r=1.6, h=2.8) hub = cmds.polyCBoolOp(hub, tmp, op=2, ch=False) # inner part of the hub hubIn = cmds.polyCylinder(r=1.6, h=1.8) # center hubCenter = cmds.polyCylinder(r=0.3, h=2.4) hubIn = cmds.polyCBoolOp(hubIn, hubCenter, op=2, ch=False) # decor parts d1 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(-0.85, moveX=True, a=True) cmds.move(-0.03, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d1, op=1, ch=False) # subtract smaller cylinder inside d1c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(-0.85, moveX=True, a=True) cmds.move(-0.03, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d1c, op=2, ch=False) d3 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(-0.422, moveX=True, a=True) cmds.move(0.648, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d3, op=1, ch=False) # subtract smaller cylinder inside d3c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(-0.422, moveX=True, a=True) cmds.move(0.648, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d3c, op=2, ch=False) d4 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(0.416, moveX=True, a=True) cmds.move(0.627, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d4, op=1, ch=False) # subtract smaller cylinder inside d4c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(0.416, moveX=True, a=True) cmds.move(0.627, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d4c, op=2, ch=False) d5 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(0.835, moveX=True, a=True) cmds.move(-0.049, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d5, op=1, ch=False) # subtract smaller cylinder inside d5c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(0.835, moveX=True, a=True) cmds.move(-0.049, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d5c, op=2, ch=False) d6 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(0.431, moveX=True, a=True) cmds.move(-0.692, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d6, op=1, ch=False) # subtract smaller cylinder inside d6c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(0.431, moveX=True, a=True) cmds.move(-0.692, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d6c, op=2, ch=False) d7 = cmds.polyCylinder(r=0.4, h=2.8) cmds.move(-0.384, moveX=True, a=True) cmds.move(-0.734, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d7, op=1, ch=False) # subtract smaller cylinder inside d7c = cmds.polyCylinder(r=0.3, h=2.9) cmds.move(-0.384, moveX=True, a=True) cmds.move(-0.734, moveZ=True, a=True) hubIn = cmds.polyCBoolOp(hubIn, d7c, op=2, ch=False) # add material myShader = cmds.shadingNode('lambert', asShader=True, name="blckMat") cmds.setAttr(nsTmp + ":blckMat.color", rgb[0], rgb[1], rgb[2], type='double3') cmds.polyUnite((nsTmp + ":*"), n=nsTmp, ch=False) cmds.rotate(90, rotateX=True, a=True) cmds.rotate(90, rotateY=True, a=True) cmds.move(3.466, moveY=True, a=True) cmds.delete(ch=True) cmds.hyperShade(assign=(nsTmp + ":blckMat")) cmds.namespace(removeNamespace=":" + nsTmp, mergeNamespaceWithParent=True)
def setUpNcloth(cls, *args): """ Main method. """ solverName = cmds.textFieldGrp(cls.widgets['solverNameTxtFldGrp'], q=True, text=True) nClothGeoList = cmds.textScrollList(cls.widgets['nClothGeoTxtScrLs'], q=True, allItems=True) colliderGeoList = cmds.textScrollList(cls.widgets['colliderGeoTxtScrLs'], q=True, allItems=True) # Create new solver if not cmds.objExists(solverName + '_nucleus'): solver = cmds.createNode('nucleus', n=solverName + '_nucleus') cmds.setAttr('%s.subSteps' % solver, 10) cmds.setAttr('%s.maxCollisionIterations' % solver, 10) cmds.setAttr('%s.timeScale' % solver, 1.0) cmds.setAttr('%s.spaceScale' % solver, 0.01) cmds.setAttr('%s.visibility' % solver, 0) cmds.connectAttr('time1.outTime', solver + '.currentTime', f=True) else: solver = solverName + '_nucleus' # Clean up outliner if not cmds.objExists(solverName + '_dyn_grp'): allGrp = cmds.createNode('transform', n=solverName + '_dyn_grp') else: allGrp = solverName + '_dyn_grp' if not cmds.objExists(solverName + '_collider_grp'): colliderGrp = cmds.createNode('transform', n=solverName + '_collider_grp') else: colliderGrp = solverName + '_collider_grp' try: cmds.parent(solver, colliderGrp, allGrp) except: pass # Collider set up if colliderGeoList: for colliderGeo in colliderGeoList: cmds.select(colliderGeo, r=True) nRgdShp = mel.eval('makeCollideNCloth;') nRgdTrsf = cmds.listRelatives(nRgdShp, p=True)[0] newNRgdName = cmds.rename(nRgdTrsf, colliderGeo + '_nRigid') # Get assigned solver to cloth newNRgdShp = cmds.listRelatives(newNRgdName, s=True) solverAssignedRgdShp = cmds.listConnections(newNRgdShp, s=False, d=True) cmds.select(newNRgdName, r=True) mel.eval('assignNSolver "%s";' % solver) # If auto created solver exists delete # if not solverAssignedRgdShp == solver: # cmds.delete(solverAssignedRgdShp) cmds.parent(newNRgdName, colliderGeo, colliderGrp) # Connect time node outTime attribute to solver currentTime attribute newNRgdShp = cmds.listRelatives(newNRgdName, s=True)[0] timeNode = cmds.listConnections('%s.currentTime' % newNRgdShp)[0] try: cmds.connectAttr('%s.outTime' % timeNode, '%s.currentTime' % solver) except: pass if nClothGeoList: for clothGeo in nClothGeoList: # Duplicate geo for 'Attract to Matching Mesh' nConstraint clothName = clothGeo.split('_dyn')[0] goalGeo = cmds.duplicate(clothGeo, n=clothName + '_goal_geo')[0] # Clean up gaolGeo and transfer skin from clothGeo cmds.select(goalGeo, r=True) tak_cleanUpModel.delHis() tak_cleanUpModel.delInterMediObj() cmds.select(clothGeo, goalGeo, r=True) tak_misc.TransSkinWeights() # Create nCloth cmds.select(clothGeo, r=True) origNclothShp = mel.eval('createNCloth 0;') nClothTrsf = cmds.listRelatives(origNclothShp, p=True)[0] newClothName = cmds.rename(nClothTrsf, clothName + '_nCloth') # Get assigned solver to cloth nClothShp = cmds.ls(cmds.listHistory(newClothName), type='nCloth') solverAssignedNcloth = list(set(cmds.ls(cmds.listConnections(nClothShp), type='nucleus')))[0] # Change solver cmds.select(newClothName, r=True) mel.eval('assignNSolver "%s";' % solver) # If auto created solver exists delete if not solverAssignedNcloth == solver: cmds.delete(solverAssignedNcloth) # Attract to Matching Mesh nConstraint cmds.select(goalGeo, clothGeo, r=True) goalCnstNodes = mel.eval('createNConstraint match 0;') cmds.setAttr('%s.constraintMethod' % goalCnstNodes[1], 0) goalCnstNRgdPrnt = cmds.listRelatives(goalCnstNodes[0], p=True)[0] goalCnstNRgd = cmds.rename(goalCnstNRgdPrnt, clothName + '_goal_cnst_nRigid') goalCnstDynCnstPrnt = cmds.listRelatives(goalCnstNodes[1], p=True)[0] goalCnstDynCnst = cmds.rename(goalCnstDynCnstPrnt, clothName + '_goal_dynCnst') # Clean up outliner clothGrp = cmds.createNode('transform', n=clothName + '_nCloth_grp') nCnstGrp = cmds.createNode('transform', n=clothName + '_nCnst_grp') cmds.setAttr('%s.visibility' % nCnstGrp, 0) cmds.parent(clothGeo, newClothName, clothGrp) cmds.parent(goalGeo, goalCnstNRgd, goalCnstDynCnst, nCnstGrp) cmds.parent(nCnstGrp, clothGrp) cmds.parent(clothGrp, allGrp)
def connectToConn(replace, iterExec, curNode, curNode2, repPattern, mode, newKeyNode, origBW): ''' Connect the newKeyNode basked on she search/replace parameters specified. ''' errorCheck = False if replace.count('%s'): currentRep = replace exec(iterExec) in locals() currentRep = currentRep % feeder newConn = curNode2.split('.')[0].replace(repPattern, currentRep) else: newConn = curNode2.split('.')[0].replace(repPattern, replace) if cmds.objExists(newConn) and \ cmds.attributeQuery( '.'.join(curNode2.split('.')[1:]), node=newConn, ex=True) and \ mode: cmds.connectAttr('%s.%s' % (newConn, '.'.join(curNode2.split('.')[1:])), '%s.input' % newKeyNode, f=True) # In driver mode, check for blendWeighted nodes. If the target # has a blendWeighted node, check to see if it has the same number # of input multi attrs, otherwise make a new one. elif cmds.objExists(newConn) and ( cmds.attributeQuery( '.'.join(curNode2.split('.')[1:]), node=newConn, ex=True) or cmds.attributeQuery( curNode2.split('.')[1].split('[')[0], node=newConn, ex=True)) \ and not mode: targetCon = cmds.listConnections( '%s.%s' % (newConn, '.'.join(curNode2.split('.')[1:])), s=True, d=False, p=True, scn=True) makeNewBW = False if targetCon: nodeType = cmds.ls(targetCon[0].split('.')[0], st=True)[1] if nodeType == 'blendWeighted': targetBWInSize = len( cmds.listAttr('%s.input' % targetCon[0].split('.')[0], multi=True)) origBWInSize = len( cmds.listAttr('%s.input' % origBW.split('.')[0], multi=True)) if targetBWInSize == origBWInSize: cmds.connectAttr('%s.output' % newKeyNode, '%s.%s' % (targetCon[0].split('.')[0], '.'.join( curNode.split('.')[1:])), f=True) else: makeNewBW = True else: makeNewBW = True else: makeNewBW = True if makeNewBW and origBW: newBW = cmds.duplicate(origBW.split('.')[0])[0] cmds.connectAttr('%s.output' % newKeyNode, '%s.%s' % (newBW, '.'.join(curNode.split('.')[1:])), f=True) cmds.connectAttr('%s.output' % newBW, '%s.%s' % (newConn, '.'.join(curNode2.split('.')[1:])), f=True) else: cmds.connectAttr('%s.output' % newKeyNode, '%s.%s' % (newConn, '.'.join(curNode2.split('.')[1:])), f=True) elif mode and cmds.objExists(newConn) and \ not cmds.attributeQuery( '.'.join(curNode2.split('.')[1:]), node=newConn, ex=True): print('\nDriver node %s does not have the attribute %s .' % (newConn, '.'.join(curNode2.split('.')[1:]))) cmds.delete(newKeyNode) else: errorCheck = True return errorCheck, newConn
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 self.currentStyle = cmds.getAttr(self.moduleGrp + ".style") # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): self.base = side + self.userGuideName + '_Guide_Base' # get the number of joints to be created: self.nJoints = cmds.getAttr(self.base + ".nJoints") # create controls: self.hipsA = ctrls.cvBox( ctrlName=side + self.userGuideName + "_" + self.langDic[self.langName]['c_hips'] + "A_Ctrl", r=self.ctrlRadius, h=(self.ctrlRadius * 0.25)) self.hipsB = \ cmds.circle(name=side + self.userGuideName + "_" + self.langDic[self.langName]['c_hips'] + "B_Ctrl", ch=False, o=True, nr=(0, 1, 0), d=1, s=8, radius=self.ctrlRadius)[0] self.chestA = ctrls.cvBox( ctrlName=side + self.userGuideName + "_" + self.langDic[self.langName]['c_chest'] + "A_Ctrl", r=self.ctrlRadius, h=(self.ctrlRadius * 0.25)) self.chestB = \ cmds.circle(name=side + self.userGuideName + "_" + self.langDic[self.langName]['c_chest'] + "B_Ctrl", ch=False, o=True, nr=(0, 1, 0), d=1, s=8, radius=self.ctrlRadius)[0] cmds.addAttr(self.hipsA, longName=side + self.userGuideName + '_' + self.langDic[self.langName]['c_volumeVariation'], attributeType="float", defaultValue=1, keyable=True) cmds.addAttr(self.hipsA, longName=side + self.userGuideName + '_active_' + self.langDic[self.langName]['c_volumeVariation'], attributeType="float", defaultValue=1, keyable=True) cmds.addAttr(self.hipsA, longName=side + self.userGuideName + '_masterScale_' + self.langDic[self.langName]['c_volumeVariation'], attributeType="float", defaultValue=1, keyable=True) ctrls.setLockHide( [self.hipsA, self.hipsB, self.chestA, self.chestB], ['v'], l=False) self.aHipsAList.append(self.hipsA) self.aChestAList.append(self.chestA) self.aVolVariationAttrList.append( side + self.userGuideName + '_' + self.langDic[self.langName]['c_volumeVariation']) self.aActVolVariationAttrList.append( side + self.userGuideName + '_active_' + self.langDic[self.langName]['c_volumeVariation']) self.aMScaleVolVariationAttrList.append( side + self.userGuideName + '_masterScale_' + self.langDic[self.langName]['c_volumeVariation']) # Setup axis order if self.rigType == Base.RigType.quadruped: cmds.setAttr(self.hipsA + ".rotateOrder", 1) cmds.setAttr(self.hipsB + ".rotateOrder", 1) cmds.setAttr(self.chestA + ".rotateOrder", 1) cmds.setAttr(self.chestB + ".rotateOrder", 1) else: cmds.setAttr(self.hipsA + ".rotateOrder", 3) cmds.setAttr(self.hipsB + ".rotateOrder", 3) cmds.setAttr(self.chestA + ".rotateOrder", 3) cmds.setAttr(self.chestB + ".rotateOrder", 3) # Keep a list of ctrls we want to colorize a certain way self.aFkCtrl.append([self.hipsB, self.chestB]) self.aIkCtrl.append([self.hipsA, self.chestA]) # organize hierarchy: cmds.parent(self.hipsB, self.hipsA) cmds.parent(self.chestB, self.chestA) if self.currentStyle == 0: #default cmds.rotate(-90, 0, 0, self.hipsA, self.chestA) cmds.makeIdentity(self.hipsA, self.chestA, apply=True, rotate=True) # position of controls: bottomLocGuide = side + self.userGuideName + "_Guide_JointLoc1" topLocGuide = side + self.userGuideName + "_Guide_JointLoc" + str( self.nJoints) # snap controls to guideLocators: cmds.delete( cmds.parentConstraint(bottomLocGuide, self.hipsA, maintainOffset=False)) cmds.delete( cmds.parentConstraint(topLocGuide, self.chestA, maintainOffset=False)) # change axis orientation for biped stype if self.currentStyle == 1: #biped cmds.rotate(0, 0, 0, self.hipsA, self.chestA) cmds.makeIdentity(self.hipsA, self.chestA, apply=True, rotate=True) cmds.parent(self.chestA, self.hipsA) # zeroOut transformations: utils.zeroOut([self.hipsA, self.chestA]) # modify the pivots of chest controls: upPivotPos = cmds.xform(side + self.userGuideName + "_Guide_JointLoc" + str(self.nJoints - 1), query=True, worldSpace=True, translation=True) cmds.move( upPivotPos[0], upPivotPos[1], upPivotPos[2], self.chestA + ".scalePivot", self.chestA + ".rotatePivot" ) # , self.chestB+".scalePivot", self.chestB+".rotatePivot") # add originedFrom attributes to hipsA, hipsB and chestB: utils.originedFrom(objName=self.hipsA, attrString=self.base) utils.originedFrom(objName=self.hipsB, attrString=bottomLocGuide) utils.originedFrom(objName=self.chestB, attrString=topLocGuide) # create a simple spine ribbon: returnedRibbonList = ctrls.createSimpleRibbon( name=side + self.userGuideName, totalJoints=(self.nJoints - 1)) rbnNurbsPlane = returnedRibbonList[0] rbnNurbsPlaneShape = returnedRibbonList[1] rbnJointGrpList = returnedRibbonList[2] self.aRbnJointList = returnedRibbonList[3] # position of ribbon nurbs plane: cmds.setAttr(rbnNurbsPlane + ".tz", -4) cmds.move(0, 0, 0, rbnNurbsPlane + ".scalePivot", rbnNurbsPlane + ".rotatePivot") cmds.rotate(90, 90, 0, rbnNurbsPlane) cmds.makeIdentity(rbnNurbsPlane, apply=True, translate=True, rotate=True) downLocPos = cmds.xform(side + self.userGuideName + "_Guide_JointLoc1", query=True, worldSpace=True, translation=True) upLocPos = cmds.xform(side + self.userGuideName + "_Guide_JointLoc" + str(self.nJoints), query=True, worldSpace=True, translation=True) cmds.move(downLocPos[0], downLocPos[1], downLocPos[2], rbnNurbsPlane) # create up and down clusters: downCluster = \ cmds.cluster(rbnNurbsPlane + ".cv[0:3][0:1]", name=side + self.userGuideName + '_Down_Cls')[1] upCluster = \ cmds.cluster(rbnNurbsPlane + ".cv[0:3][" + str(self.nJoints) + ":" + str(self.nJoints + 1) + "]", name=side + self.userGuideName + '_Up_Cls')[1] # get positions of joints from ribbon nurbs plane: startRbnJointPos = cmds.xform(side + self.userGuideName + "_00_Jnt", query=True, worldSpace=True, translation=True) endRbnJointPos = cmds.xform(side + self.userGuideName + "_%02d_Jnt" % (self.nJoints - 1), query=True, worldSpace=True, translation=True) # move pivots of clusters to start and end positions: cmds.move(startRbnJointPos[0], startRbnJointPos[1], startRbnJointPos[2], downCluster + ".scalePivot", downCluster + ".rotatePivot") cmds.move(endRbnJointPos[0], endRbnJointPos[1], endRbnJointPos[2], upCluster + ".scalePivot", upCluster + ".rotatePivot") # snap clusters to guideLocators: tempDel = cmds.parentConstraint(bottomLocGuide, downCluster, maintainOffset=False) cmds.delete(tempDel) tempDel = cmds.parentConstraint(topLocGuide, upCluster, maintainOffset=False) cmds.delete(tempDel) # rotate clusters to compensate guide: upClusterRot = cmds.xform(upCluster, query=True, worldSpace=True, rotation=True) downClusterRot = cmds.xform(downCluster, query=True, worldSpace=True, rotation=True) cmds.xform(upCluster, worldSpace=True, rotation=(upClusterRot[0] + 90, upClusterRot[1], upClusterRot[2])) cmds.xform(downCluster, worldSpace=True, rotation=(downClusterRot[0] + 90, downClusterRot[1], downClusterRot[2])) # scaleY of the clusters in order to avoid great extremity deforms: rbnHeight = ctrls.distanceBet( side + self.userGuideName + "_Guide_JointLoc" + str(self.nJoints), side + self.userGuideName + "_Guide_JointLoc1", keep=False)[0] cmds.setAttr(upCluster + ".sy", rbnHeight / 10) cmds.setAttr(downCluster + ".sy", rbnHeight / 10) # parent clusters in controls (up and down): cmds.parentConstraint(self.hipsB, downCluster, maintainOffset=True, name=downCluster + "_ParentConstraint") cmds.parentConstraint(self.chestB, upCluster, maintainOffset=True, name=upCluster + "_ParentConstraint") # organize a group of clusters: clustersGrp = cmds.group(name=side + self.userGuideName + "_Rbn_Clusters_Grp", empty=True) self.aClusterGrp.append(clustersGrp) if hideJoints: cmds.setAttr(clustersGrp + ".visibility", 0) cmds.parent(downCluster, upCluster, clustersGrp, relative=True) # make ribbon joints groups scalable: for r, rbnJntGrp in enumerate(rbnJointGrpList): if ((r > 0) and (r < (len(rbnJointGrpList) - 1))): scaleGrp = cmds.group(rbnJntGrp, name=rbnJntGrp.replace( "_Grp", "_Scale_Grp")) ctrls.directConnect(scaleGrp, rbnJntGrp, ['sx', 'sz']) cmds.scaleConstraint(clustersGrp, scaleGrp, maintainOffset=True, name=rbnJntGrp + "_Scale") else: cmds.scaleConstraint(clustersGrp, rbnJntGrp, maintainOffset=True, name=rbnJntGrp + "_Scale") # calculate the distance to volumeVariation: arcLenShape = cmds.createNode('arcLengthDimension', name=side + self.userGuideName + "_Rbn_ArcLenShape") arcLenFather = cmds.listRelatives(arcLenShape, parent=True)[0] arcLen = cmds.rename(arcLenFather, side + self.userGuideName + "_Rbn_ArcLen") arcLenShape = cmds.listRelatives(arcLen, children=True, shapes=True)[0] cmds.setAttr(arcLen + '.visibility', 0) # connect nurbsPlaneShape to arcLength node: cmds.connectAttr(rbnNurbsPlaneShape + '.worldSpace[0]', arcLenShape + '.nurbsGeometry') cmds.setAttr(arcLenShape + '.vParamValue', 1) # avoid undesired squash if rotateZ the nurbsPlane: cmds.setAttr(arcLenShape + '.uParamValue', 0.5) arcLenValue = cmds.getAttr(arcLenShape + '.arcLengthInV') # create a multiplyDivide to output the squashStretch values: rbnMD = cmds.createNode('multiplyDivide', name=side + self.userGuideName + "_Rbn_MD") cmds.connectAttr(arcLenShape + '.arcLengthInV', rbnMD + '.input2X') cmds.setAttr(rbnMD + '.input1X', arcLenValue) cmds.setAttr(rbnMD + '.operation', 2) # create a blendColor, a condition and a multiplyDivide in order to get the correct result value of volumeVariation: rbnBlendColors = cmds.createNode( 'blendColors', name=side + self.userGuideName + "_Rbn_BlendColor") cmds.connectAttr( self.hipsA + '.' + side + self.userGuideName + '_' + self.langDic[self.langName]['c_volumeVariation'], rbnBlendColors + '.blender') rbnCond = cmds.createNode('condition', name=side + self.userGuideName + '_Rbn_Cond') cmds.connectAttr( self.hipsA + '.' + side + self.userGuideName + '_active_' + self.langDic[self.langName]['c_volumeVariation'], rbnCond + '.firstTerm') cmds.connectAttr(rbnBlendColors + '.outputR', rbnCond + '.colorIfTrueR') cmds.connectAttr(rbnMD + '.outputX', rbnBlendColors + '.color1R') rbnVVMD = cmds.createNode('multiplyDivide', name=side + self.userGuideName + "_Rbn_VV_MD") cmds.connectAttr( self.hipsA + '.' + side + self.userGuideName + '_masterScale_' + self.langDic[self.langName]['c_volumeVariation'], rbnVVMD + '.input2X') cmds.connectAttr(rbnVVMD + '.outputX', rbnCond + '.colorIfFalseR') cmds.setAttr(rbnVVMD + '.operation', 2) cmds.setAttr(rbnBlendColors + '.color2R', 1) cmds.setAttr(rbnCond + ".secondTerm", 1) # middle ribbon setup: for n in range(1, self.nJoints - 1): if self.currentStyle == 0: #default self.middle = cmds.circle( name=side + self.userGuideName + "_" + self.langDic[self.langName]['c_middle'] + str(n) + "_Ctrl", ch=False, o=True, nr=(0, 0, 1), d=3, s=8, radius=self.ctrlRadius)[0] cmds.setAttr(self.middle + ".rotateOrder", 4) else: #biped self.middle = cmds.circle( name=side + self.userGuideName + "_" + self.langDic[self.langName]['c_middle'] + str(n) + "_Ctrl", ch=False, o=True, nr=(0, 1, 0), d=3, s=8, radius=self.ctrlRadius)[0] cmds.setAttr(self.middle + ".rotateOrder", 3) self.aFkCtrl[s].append(self.middle) ctrls.setLockHide([self.middle], ['sx', 'sy', 'sz']) cmds.setAttr(self.middle + '.visibility', keyable=False) cmds.parent(self.middle, self.hipsA) middleLocGuide = side + self.userGuideName + "_Guide_JointLoc" + str( n + 1) cmds.delete( cmds.parentConstraint(middleLocGuide, self.middle, maintainOffset=False)) if self.currentStyle == 1: #biped cmds.rotate(0, 0, 0, self.middle) utils.zeroOut([self.middle]) middleCluster = cmds.cluster( rbnNurbsPlane + ".cv[0:3][" + str(n + 1) + "]", name=side + self.userGuideName + '_Middle_Cls')[1] middleLocPos = cmds.xform(side + self.userGuideName + "_Guide_JointLoc" + str(n), query=True, worldSpace=True, translation=True) tempDel = cmds.parentConstraint(middleLocGuide, middleCluster, maintainOffset=False) cmds.delete(tempDel) middleClusterRot = cmds.xform(middleCluster, query=True, worldSpace=True, rotation=True) cmds.xform(middleCluster, worldSpace=True, rotation=(middleClusterRot[0] + 90, middleClusterRot[1], middleClusterRot[2])) cmds.parentConstraint(self.middle, middleCluster, maintainOffset=True, name=middleCluster + "_ParentConstraint") # parenting constraints like guide locators: self.parentConst = cmds.parentConstraint( self.hipsB, self.chestB, self.middle + "_Zero", name=self.middle + "_ParentConstraint", maintainOffset=True)[0] nParentValue = (n) / float(self.nJoints - 1) cmds.setAttr(self.parentConst + "." + self.hipsB + "W0", 1 - nParentValue) cmds.setAttr(self.parentConst + "." + self.chestB + "W1", nParentValue) cmds.parent(middleCluster, clustersGrp, relative=True) # add originedFrom attribute to this middle ctrl: utils.originedFrom(objName=self.middle, attrString=middleLocGuide) # apply volumeVariation to joints in the middle ribbon setup: cmds.connectAttr(rbnCond + '.outColorR', self.aRbnJointList[n] + '.scaleX') cmds.connectAttr(rbnCond + '.outColorR', self.aRbnJointList[n] + '.scaleZ') # update spine volume variation setup currentVV = cmds.getAttr(rbnMD + '.outputX') cmds.setAttr(rbnVVMD + '.input1X', currentVV) # organize groups: self.rbnRigGrp = cmds.group(name=side + self.userGuideName + "_Grp", empty=True) self.rbnControlGrp = cmds.group( name=side + self.userGuideName + "_Control_Grp", empty=True) cmds.parent(self.hipsA + "_Zero", self.rbnControlGrp, relative=True) cmds.parent(clustersGrp, side + self.userGuideName + "_Rbn_RibbonJoint_Grp", self.rbnControlGrp, arcLen, self.rbnRigGrp, relative=True) if hideJoints: cmds.setAttr( side + self.userGuideName + "_Rbn_RibbonJoint_Grp.visibility", 0) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.rbnControlGrp, hookType='ctrlHook') utils.addHook(objName=clustersGrp, hookType='scalableHook') utils.addHook(objName=self.rbnRigGrp, hookType='staticHook') cmds.addAttr(self.rbnRigGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.rbnRigGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.rbnRigGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.rbnRigGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.rbnRigGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.rbnRigGrp + '.dpAR_count', dpAR_count) # lockHide scale of up and down controls: ctrls.setLockHide( [self.hipsA, self.hipsB, self.chestA, self.chestB], ['sx', 'sy', 'sz']) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()
def patch(): #vars######################################################################################### sides = ['L', 'R'] intFixes = ['front', 'back'] fullLegDuplicate = ['leg_01', 'leg_02', 'foot_01', 'foot_02'] ############################################################################################## for side in sides: if side == 'L': ctrlcolor = 6 elif side == 'R': ctrlcolor = 13 #duplicates legs joints to create new fullLeg chain###################################################### newChain = [] for i, joint in enumerate(fullLegDuplicate): target = '%s_%s_%s' % (side, intFixes[1], joint) if mc.objExists(target): newjoint = mc.duplicate(target, po=True)[0] patchLib.locksSwitch(newjoint, T=True, R=True, S=True, V=True, lockdo='unlock', keydo=True) mc.parent(newjoint, w=True) newName = '%s_%s_fullLeg_%02d' % (side, intFixes[1], (i + 1)) mc.rename(newjoint, newName) newChain.append(newName) if newChain: mc.parent(newChain[3], newChain[2]) mc.parent(newChain[2], newChain[1]) mc.parent(newChain[1], newChain[0]) ##parents new fullLeg at the same place as base legs######################################################## newParent = mc.listRelatives('%s_%s_leg_01_orig' % (side, intFixes[1]), p=True)[0] mc.parent(newChain[0], newParent) ############################################################################################################ #creates new upvector and ik for fullLeg#################################################################### duplicatedUpVector = mc.duplicate('%s_%s_leg_PV_ctrl' % (side, intFixes[1]))[0] fullLegUpV = mc.rename(duplicatedUpVector, '%s_%s_fullLeg_PV_ctrl' % (side, intFixes[1])) shapes.create(fullLegUpV, shape='pyramid', size=1, scale=[1, 1, 1], axis='y', twist=0, offset=[0, 0, 0], color=ctrlcolor, colorDegradeTo=None, replace=True, middle=False) fullLegUpVOrig = orig.orig(objlist=[fullLegUpV], suffix=['_orig'], origtype='transform', fromsel=False, viz=False, get_ssc=False, rtyp='auto')[0] mc.parent(fullLegUpVOrig, 'traj') ###scales newUpvector shape up ########################################################## scalePoints = mc.ls('%s.cv[*]' % fullLegUpV, fl=True) mc.scale(1.25, 1.25, 1.25, scalePoints, r=True, ocp=True) ##creates ik for fullLeg################################################################################### fullLegIkName = '%s_%s_fullLeg_ikh' % (side, intFixes[1]) fullLegIk = mc.ikHandle(sj=newChain[0], ee=newChain[3], n=fullLegIkName, sol='ikRPsolver') mc.poleVectorConstraint(fullLegUpV, fullLegIk[0]) ##reparent log upV in FullLeg upV and replace constraint upVCnsName = '%s_%s_leg_PV_ctrl_orig_parentConstraint1' % (side, intFixes[1]) upVCnsTarget = mc.parentConstraint(upVCnsName, q=True, tl=True)[0] mc.delete(upVCnsName) legUpVOrig = '%s_%s_leg_PV_ctrl_orig' % (side, intFixes[1]) mc.parent(legUpVOrig, fullLegUpV) mc.parentConstraint(upVCnsTarget, fullLegUpVOrig, mo=True) ############################################################################################################ #updating original ball 01 and 02 rigs###################################################################### ball01 = '%s_%s_leg_rvfoot_ball_01_ctrl' % (side, intFixes[1]) ball02Orig = '%s_%s_leg_rvfoot_ball_02_ctrl_orig' % (side, intFixes[1]) ball02 = '%s_%s_leg_rvfoot_ball_02_ctrl' % (side, intFixes[1]) #updating original ball_01 rig############################################################################## ##ads ik offset on ball01################################################################################### patchLib.locksSwitch(ball01, T=True, R=True, S=True, V=True, lockdo='unlock', keydo=True) ball01ik = mc.duplicate(ball01, po=True) ball01ikend = mc.duplicate(ball02Orig, po=True) ball01ikName = '%s_%s_leg_ik_rvfoot_ball_01_joint' % (side, intFixes[1]) ball01ikEndName = '%s_%s_leg_ik_rvfoot_ball_01_end' % (side, intFixes[1]) ball01ik = mc.rename(ball01ik, ball01ikName) ball01ikend = mc.rename(ball01ikend, ball01ikEndName) mc.parent(ball01ikend, ball01ik) mc.parent(ball01, ball01ik) ###creates ctrl for ball01 ik offset########################################################################### ballIKCtrlname = '%s_%s_leg_rvfoot_ik_ball_01_ctrl' % (side, intFixes[1]) mc.select(cl=True) ballIKCtrl = mc.joint(n=ballIKCtrlname) mc.setAttr('%s.drawStyle' % ballIKCtrl, 2) ballIKCtrlOrig = orig.orig(objlist=[ballIKCtrl], suffix=['_orig'], origtype='joint', fromsel=False, viz=False, get_ssc=False, rtyp='auto')[0] shapes.create(ballIKCtrl, shape='cube', size=.25, scale=[1, .5, 1], axis='y', twist=0, offset=[0, 0, 0], color=ctrlcolor, colorDegradeTo=None, replace=True, middle=False) mc.parent(ballIKCtrlOrig, ball01ikend) mc.setAttr('%s.translate' % ballIKCtrlOrig, 0, 0, 0) mc.parent(ballIKCtrlOrig, (mc.listRelatives(ball01ik, p=True))) ###creates ikSCsolver for ball 01 ik ##################################################################### ball01ikhName = '%s_%s_leg_rvfoot_ik_ball_01_ikh' % (side, intFixes[1]) ball01ikh = mc.ikHandle(sj=ball01ik, ee=ball01ikend, n=ball01ikhName, sol='ikSCsolver') mc.parent(ball01ikh[0], ballIKCtrl) patchLib.locksSwitch(ball01, T=True, R=False, S=True, V=True, lockdo='lock', keydo=False) #updating original ball_02 rig############################################################################## ##remove original aim constraint############################################################################ ball02AimCns = mc.listConnections('%s.rotateX' % ball02Orig)[0] mc.delete(ball02AimCns) ##ads ik offset on ball02################################################################################### ballDublicate = [ ball02Orig, '%s_%s_leg_rvfoot_ball_02_ctrl' % (side, intFixes[1]), '%s_%s_leg_rvfoot_ankle_ctrl' % (side, intFixes[1]) ] newBall = [] for j, ballJnt in enumerate(ballDublicate): newJnt = mc.duplicate(ballJnt, po=True) newJntName = ballDublicate[j].replace('rvfoot', 'rvfoot_ik') newJntName = newJntName.replace('ctrl', 'jnt') mc.rename(newJnt, newJntName) newBall.append(newJntName) mc.parent(newBall[2], newBall[1]) mc.parent(newBall[1], newBall[0]) mc.parent(newBall[0], ball02Orig) mc.parent(ball02, newBall[1]) ###creates ikSCsolver for ball ik offset##################################################################### ball02ikhName = '%s_%s_leg_rvfoot_ik_ball_02_ikh' % (side, intFixes[1]) ball02ikh = mc.ikHandle(sj=newBall[1], ee=newBall[2], n=ball02ikhName, sol='ikSCsolver') ###creates ctrl for ball ik offset########################################################################### ballIKCtrlname = '%s_%s_leg_rvfoot_ik_ball_02_ctrl' % (side, intFixes[1]) mc.select(cl=True) ballIKCtrl = mc.joint(n=ballIKCtrlname) mc.setAttr('%s.drawStyle' % ballIKCtrl, 2) ballIKCtrlOrig = orig.orig(objlist=[ballIKCtrl], suffix=['_orig'], origtype='joint', fromsel=False, viz=False, get_ssc=False, rtyp='auto')[0] if side == 'L': ctrlcolor = 6 elif side == 'R': ctrlcolor = 13 shapes.create(ballIKCtrl, shape='locator', size=1, scale=[1, 1, 1], axis='y', twist=0, offset=[0, 0, 0], color=ctrlcolor, colorDegradeTo=None, replace=True, middle=False) mc.parent(ballIKCtrlOrig, newBall[2], r=True) mc.parent(ballIKCtrlOrig, newBall[0]) ####adjusts ctrl position#################################################################################### mc.setAttr('%s.translateY' % ballIKCtrlOrig, (mc.getAttr('%s.translateY' % ballIKCtrlOrig)) * 2) mc.xform(ballIKCtrlOrig, ws=True, r=True, a=True, ro=(0, 0, 0)) if side == 'L': mc.setAttr('%s.jointOrientX' % ballIKCtrl, 180 - (mc.getAttr('%s.rotateX' % ballIKCtrlOrig))) if side == 'R': mc.setAttr('%s.jointOrientX' % ballIKCtrl, -(mc.getAttr('%s.rotateX' % ballIKCtrlOrig))) ##parents ball 02 ikh into ctrl############################################################################## mc.parent(ball02ikh[0], ballIKCtrl) mc.setAttr('%s.translate' % ball02ikh[0], 0, 0, 0) ##constraints updated ball02 to fullLeg###################################################################### mc.parentConstraint(newChain[3], newBall[0], st=["x", "y", "z"], mo=True) ##connects translate of fullLegs first joint to base legs first joint####################################### mc.connectAttr('%s.translate' % newChain[0], '%s_%s_leg_01_orig.translate' % (side, intFixes[1]), f=True) ##parent new ikh############################################################################################ fullLegParent = '%s_%s_leg_rvfoot_ball_01_ctrl' % (side, intFixes[1]) mc.parent(fullLegIk[0], fullLegParent) ############################################################################################################## #temp remove front aim cns on ball_02 mc.delete('%s_%s_leg_rvfoot_ball_02_ctrl_orig_aimConstraint1' % (side, intFixes[0])) ############################################################################################################## # rough cleanup hideList = [ 'leg_rvfoot_ik_ball_02_ikh', 'fullLeg_ikh', 'leg_rvfoot_ik_ball_01_ikh', 'fullLeg_01' ] for toHide in hideList: mc.hide('%s_%s_%s' % (side, intFixes[1], toHide))
def generateLODS(self): x = self.ui.selectedGeo_groupBox.title() x = (x.replace('Selected Mesh: ', '')) fullPath = str(cmds.ls(x, long=True)[0]) if fullPath: print fullPath obSl = fullPath if len(obSl) == 0: cmds.confirmDialog( title='Error:', message='No objects selected for polygon reduction') else: print('\n') cmds.select(obSl) lods = [] LOD01_Val = [] LOD02_Val = [] LOD03_Val = [] currentIndex = self.whatTab() print currentIndex if currentIndex == 0: LOD1_Number = int(self.ui.LOD1_num.text()) LOD2_Number = int(self.ui.LOD2_num.text()) LOD3_Number = int(self.ui.LOD3_num.text()) LOD3_Number = int(self.ui.LOD3_num.text()) LOD01_Val.append(LOD1_Number) LOD02_Val.append(LOD2_Number) LOD03_Val.append(LOD3_Number) else: LOD01_Percent = self.ui.LOD1_horizontalSlider.value() LOD02_Percent = self.ui.LOD2_horizontalSlider.value() LOD03_Percent = self.ui.LOD3_horizontalSlider.value() currentMeshPolyGonCount = cmds.polyEvaluate(f=True) print currentMeshPolyGonCount LOD01_PolyPercent = (LOD01_Percent * currentMeshPolyGonCount) / 100 LOD02_PolyPercent = (LOD02_Percent * currentMeshPolyGonCount) / 100 LOD03_PolyPercent = (LOD03_Percent * currentMeshPolyGonCount) / 100 LOD01_Val.append(LOD01_PolyPercent) LOD02_Val.append(LOD02_PolyPercent) LOD03_Val.append(LOD03_PolyPercent) LOD0_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD0')) lods.append(LOD0_LOD) #print LOD01_Val,LOD02_Val,LOD03_Val if self.ui.LOD1_chkBox.isChecked(): LOD1_Num = LOD01_Val[0] LOD1_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD1')) self.genFunction(LOD1_LOD, LOD1_Num) lods.append(LOD1_LOD) print('"__LOD1"__LOD__generated__Successfully :~- ' + str(LOD1_LOD)) if self.ui.LOD2_chkBox.isChecked(): LOD2_Num = LOD02_Val[0] LOD2_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD2')) self.genFunction(LOD2_LOD, LOD2_Num) lods.append(LOD2_LOD) print('"__LOD2"__LOD__generated__Successfully :~- ' + str(LOD2_LOD)) if self.ui.LOD3_chkBox.isChecked(): LOD3_Num = LOD03_Val[0] LOD3_LOD = cmds.duplicate(obSl, name=(obSl + '__LOD3')) self.genFunction(LOD3_LOD, LOD3_Num) lods.append(LOD3_LOD) print('"__LOD3"__LOD__generated__Successfully :~- ' + str(LOD3_LOD)) if self.ui.WRAP_chkBox.isChecked(): WRAP_Num = str(self.ui.wrap_comboBox.currentText()) print WRAP_Num LOD5_LOD = cmds.CreatePolygonSoccerBall(n=obSl + '__LOD4') newMesh = cmds.rename(LOD5_LOD, (obSl + '__LOD4')) if WRAP_Num == '180': cmds.polySmooth(newMesh, divisions=1) if WRAP_Num == '720': cmds.polySmooth(newMesh, divisions=2) if WRAP_Num == '2880': cmds.polySmooth(newMesh, divisions=3) cmds.delete(newMesh, ch=True) bbox = cmds.exactWorldBoundingBox(obSl) x1, y1, z1, x2, y2, z2 = cmds.exactWorldBoundingBox(obSl) xc = (x2 + x1) / 2.0 yc = (y2 + y1) / 2.0 zc = (z2 + z1) / 2.0 xw = x2 - x1 yw = y2 - y1 zw = z2 - z1 cmds.move(xc, yc, zc, newMesh) cmds.scale(xw, yw, zw, newMesh) shrinkWrapNode = pm.deformer(newMesh, type='shrinkWrap')[0] pm.PyNode(obSl).worldMesh[0] >> shrinkWrapNode.targetGeom shrinkWrapNode.closestIfNoIntersection.set(True) cmds.delete(newMesh, ch=True) cmds.select(clear=True) cmds.select(newMesh) cmds.select(obSl, add=True) self.copyPivot() lods.append(newMesh) if self.ui.BBOX_chkBox.isChecked(): print('make a bounding box') cmds.select(obSl) box = self.MakeCube() newmeshBox = cmds.rename(box, (obSl + '__LOD5')) lods.append(newmeshBox) cmds.select(obSl) cmds.select(newmeshBox, add=True) self.copyPivot() cmds.select(clear=True) if lods == []: pass else: grp = (obSl + '__LOD_grp') if cmds.objExists(grp): pass else: lod_grp = cmds.group(n=grp, em=True) print grp for lod in lods: print lod cmds.parent(lod, grp) print('\n') cmds.inViewMessage(amg="LOD generated successfully", pos="botCenter", fade=True) print('Done') else: cmds.confirmDialog( title='Error:', message='No objects selected for polygon reduction')
def createHouse(scaleX, scaleY, scaleZ, r, g, b, numOfHouses, randX, randY, randZ, rotateX, rotateY, rotateZ): for i in range(numOfHouses): # Create new scene every time program runs mc.file(new=True, force=True) """ Below, we create the roof for the house """ # Roof roof = mc.polyPyramid(n='roof') mc.scale(28.147, 12.410, 28.373) mc.move(1.167, 32.273, 0) mc.setAttr('roof.ry', 45) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(roof) # ColorLambert and HyperShade are for setting color of the object mc.setAttr((colorLambert + '.color'), r, g, b, type='double3') mc.hyperShade(assign=colorLambert) mc.polyMoveVertex('roof.vtx[0:1]', tx=-25.3) mc.polyMoveVertex('roof.vtx[4]', tx=-10.3) # Roof 2 roof2 = mc.polyPyramid(n='roof2') mc.scale(28.147, 12.410, 28.373) mc.move(1.167, 28.601, -28.944) mc.setAttr('roof2.rx', -20.000) mc.setAttr('roof2.ry', 43.000) mc.setAttr('roof2.rz', -13.500) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(roof2) #mc.setAttr((colorLambert + '.color'), 0.5725, 0.1686, 0.129, type = 'double3') mc.setAttr((colorLambert + '.color'), r, g, b, type='double3') mc.hyperShade(assign=colorLambert) mc.polyMoveVertex('roof2.vtx[0:1]', tx=-25.3) mc.polyMoveVertex('roof2.vtx[4]', tx=-10.3) """ Below, we create the windows for the house """ # Windows # Front top above garage for i in range(1): windows = mc.polyCube(n='windowsFrontTop') mc.scale(0.420, 5.886, 9.002) mc.move(11.975, 23.622, -10.279 * -i) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(windows) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # Left Side on 2nd story for i in range(0, 2): windows = mc.polyCube(n='windowsRightSideBottom') mc.scale(0.420, 3.325, 5.290) mc.rotate(0, 90, 0) mc.move(-15.612 * i, 23.622, 13.253) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(windows) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # Rear windows on 2nd story for i in range(-1, 1): windows = mc.polyCube(n='windowsFrontBottom') mc.scale(0.420, 3, 2.940) mc.move(-33.978, 23.622, 8.921 * -i) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(windows) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # 2 end windows near Front Door for i in range(2): frontDoorEndWindow = mc.polyCube(n='frontDoorEndWindow') mc.scale(0.627, 4.665, 2.428) mc.move(-4.546, 13.984, -27.740 - (10 * i)) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(frontDoorEndWindow) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # Window near Front Door for i in range(1): frontDoorWindow = mc.polyCube(n='frontDoorWindow') mc.scale(0.627, 4.665, 7.094) mc.move(-4.546, 13.984, -32.742) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(frontDoorWindow) #mc.setAttr((colorLambert + '.color'), 0.412, 0.412, 0.412, type = 'double3' ) mc.setAttr((colorLambert + '.color'), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), type='double3') mc.hyperShade(assign=colorLambert) # Rear window near ground floor bedroom for i in range(1): windowsRearBottomNearBedroom = mc.polyCube( n='windowsRearBottomNearBedroom') mc.scale(0.420, 3, 6.388) mc.move(-33.978, 14.686, -19.139) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(windowsRearBottomNearBedroom) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # Rear window near kitchen for i in range(1): windowsRearBottomNearKitchen = mc.polyCube( n='windowsRearBottomNearKitchen') mc.scale(0.420, 7.818, 4.556) mc.move(-33.978, 10.546, -36.449) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(windowsRearBottomNearKitchen) mc.setAttr((colorLambert + '.color'), 0, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) """ Below, we create the main and right side of the building for the house """ # main building building = mc.polyCube(n='building') mc.scale(25.963, 26.190, 45.551) mc.move(-10.958, 14.810, 0) mc.setAttr('building.ry', 90) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(building) #mc.setAttr((colorLambert + '.color'), r, g, b, type = 'double3' ) mc.setAttr((colorLambert + '.color'), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), type='double3') mc.hyperShade(assign=colorLambert) mc.polySplitVertex('building.vtx[2:5]') # Right side of building rightSide = mc.polyCube(n='rightSide') mc.scale(28.082, 7.793, 29.276) mc.rotate(0, 90, 0) mc.move(-19.041, 5.623, -26.999) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(rightSide) #mc.setAttr((colorLambert + '.color'), r, g, b, type = 'double3' ) mc.setAttr((colorLambert + '.color'), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), random.uniform(0.0, 1.0), type='double3') mc.hyperShade(assign=colorLambert) mc.polyMoveVertex('rightSide.vtx[2]', 'rightSide.vtx[4]', ty=18.4) mc.polyMoveVertex('rightSide.vtx[3]', 'rightSide.vtx[5]', ty=10) mc.polyMoveVertex('rightSide.vtx[3]', ty=1) mc.polyMoveVertex('rightSide.vtx[5]', ty=1) """ Below, we create the front doors and the garage door """ # 2 Front Doors for i in range(2): frontDoor = mc.polyCube(n='frontDoor') mc.scale(0.627, 8.678, 4.392) mc.move(-4.546, 6.086, -15.466 - (4.5 * i)) colorLambert = mc.shadingNode('lambert', asShader=True) mc.select(frontDoor) mc.setAttr((colorLambert + '.color'), 0.5, 0, 0, type='double3') mc.hyperShade(assign=colorLambert) # Garage Door for i in range(1): garageDoor = mc.polyCube(n='garageDoor') mc.move(11.982, 6.060 + (2.35 * i), 0) mc.scale(0.277, 8.664, 18.652) mc.select(garageDoor) # polyUnite() will gather the objects and will merge all of them together. This allows to scale the entire house without having to worry about modifying the coordinates of the windows, roof, and other components of the house house = mc.polyUnite('rightSide', 'building', 'garageDoor', 'windowsRightSideBottom', 'windowsRightSideBottom1', 'windowsFrontBottom1', 'windowsFrontTop', 'frontDoorEndWindow1', 'roof', 'frontDoor1', 'frontDoor', 'roof2', 'windowsFrontBottom', 'windowsRearBottomNearKitchen', 'windowsRearBottomNearBedroom', 'frontDoorWindow', 'frontDoorEndWindow', n='house') mc.setAttr('house.translateX', 54) # Here we are spawning the number of houses into the scene for i in range(1, numOfHouses): mc.scale(scaleX / 10, scaleY / 10, scaleZ / 10, house) mc.duplicate('house', smartTransform=False) mc.setAttr('house.translateX', 54) mc.setAttr('house%d.rx' % i, rotateX) mc.setAttr('house%d.ry' % i, rotateY) mc.setAttr('house%d.rz' % i, rotateZ) mc.setAttr('house%d.tx' % i, 54 - randX) mc.setAttr('house%d.ty' % i, 2 * i * randY) mc.setAttr('house%d.tz' % i, i * 5 * randZ) #mc.xform('house%d' % i, translation=[54 - randX, 2 * i * randY, 5 * i * randZ]) return house # Now we return the object
def upperArmTwist(color, rollGrpParent, fkArmJoint, ikArmJoint, suffix, name, prefix, upperArm, lowerArm): print "START Building the " + suffix + " UPPER arm twists---------------------------------------" #create a nice name name = prefix + name + suffix if name.find("_") == 0: name = name.partition("_")[2] # define the joints for this rig. upperarm = prefix + upperArm + suffix lowerarm = prefix + lowerArm + suffix driver_clavicle = "driver_" + prefix + "clavicle" + suffix driver_upperarm = "driver_deltoid_" + prefix + upperArm + suffix driver_lowerarm = "driver_" + prefix + lowerArm + suffix numRolls = 0 for joint in [ "_twist_01", "_twist_02", "_twist_03", "_twist_04", "_twist_05", "_twist_06" ]: if cmds.objExists("driver_" + prefix + upperArm + joint + suffix): numRolls = numRolls + 1 print "...There are a total of " + str(numRolls) + " to build." for i in range(int(numRolls)): print "...Building upper arm twist_0" + str(i + 1) driver_upperarm_twist = "driver_" + prefix + upperArm + "_twist_0" + str( i + 1) + suffix rollGrp = cmds.group(empty=True, name=upperarm + "_roll_grp_0" + str(i + 1)) cmds.parent(rollGrp, "arm_sys_grp") # Move the driver_upperarm_twist joint to its correct position between the driver_upperarm and its driver_lowerarm using a point constraint. const = cmds.parentConstraint(driver_upperarm, driver_upperarm_twist, n=driver_upperarm + "_temp_parentConst", weight=1) cmds.delete(const) const = cmds.pointConstraint(driver_upperarm, driver_lowerarm, driver_upperarm_twist, n=driver_upperarm + "_temp_PointConst", weight=1) cmds.delete(const) # Duplicate the driver_upperarm, driver_lowerarm, and driver_upperarm_twist joints blendJnts = [] blend_driver_upperarmParent = cmds.duplicate( driver_upperarm, n="Blend_" + driver_upperarm + "_parent_ignore_0" + str(i + 1), ic=True, po=True)[0] blendJnts.append(blend_driver_upperarmParent) blend_driver_lowerarm = cmds.duplicate( driver_lowerarm, n="Blend_" + driver_lowerarm + "_ignore_0" + str(i + 1), ic=True, po=True)[0] blendJnts.append(blend_driver_lowerarm) blend_driver_upperarm = cmds.duplicate( driver_upperarm, n="Blend_" + driver_upperarm + "_ignore_0" + str(i + 1), po=True)[0] blendJnts.append(blend_driver_upperarm) blend_driver_upperarm_twist = cmds.duplicate( driver_upperarm_twist, n="Blend_" + driver_upperarm_twist + "_ignore_0" + str(i + 1), ic=True, po=True)[0] blendJnts.append(blend_driver_upperarm_twist) cmds.parent(blend_driver_lowerarm, blend_driver_upperarm_twist, blend_driver_upperarmParent) cmds.parent(blend_driver_upperarm, blend_driver_upperarm_twist) # Set the parent bone to have zyx rotation order cmds.setAttr(blend_driver_upperarmParent + ".rotateOrder", 2) originalJnts = [driver_upperarm, driver_lowerarm] #print originalJnts # Now we are going to disconnect the constraints that were driving the original driver_upperarm # and driver_lowerarm joints and re-connect them to the parent_ignore and ignore joints that were duped from them. # This is so that we can create new constraints on the driver_upperarm and driver_lowerarm joints for the rig. j = 0 a = 0 #while a < len(originalJnts): for a in range(0, len(originalJnts)): # Go through the inputs of the original joints and disconnect them origConn = cmds.listConnections(originalJnts[a], d=False, c=+ True, p=True) for j in range(0, len(origConn), 2): cmds.disconnectAttr(origConn[j + 1], origConn[j]) nameList = origConn[j + 1].split(".")[0] destConn = cmds.listConnections(nameList, s=False) # Find out if the node that was an input to the original joint is also an output if originalJnts[a] in destConn: sourceConn = cmds.listConnections(nameList, d=False, c=True, p=True) for k in range(0, len(sourceConn), 2): # Get the input connections to the node that are connected to the original joint nameConnList = sourceConn[k + 1].split(".") if (nameConnList[0] == originalJnts[a]): # Disconnect from the original joint and connect to the blend joint cmds.disconnectAttr(sourceConn[k + 1], sourceConn[k]) nameConnList[0] = blendJnts[a] cmds.connectAttr( nameConnList[0] + "." + nameConnList[-1], sourceConn[k]) # create the manual twist control if i == 0: twistCtrl = utils.createControl("circle", 15, upperarm + "_twist_anim") else: twistCtrl = utils.createControl( "circle", 15, upperarm + "_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(blend_driver_upperarm_twist, 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(blend_driver_upperarm_twist, 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(blend_driver_upperarm_twist, 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 + "twistCtrlVisUpper"), at='bool', dv=0, keyable=True) cmds.connectAttr("Rig_Settings." + name + "twistCtrlVisUpper", twistCtrl + ".v") # add attr to rig settings for the twist ammount values cmds.select("Rig_Settings") cmds.addAttr(longName=(name + "UpperarmTwist" + 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 + "UpperarmTwist" + str(u + 1) + "Amount", (1.0 / (i + 2.0) * ((2.0 - u) + (i - 1.0)))) cmds.parent(blend_driver_upperarmParent, rollGrp) # Constrain the original joints to the blend joints cmds.orientConstraint(blend_driver_upperarm, driver_upperarm, n=driver_upperarm + "_0" + str(i + 1) + "_OrntCnst", mo=True, w=1) cmds.pointConstraint(blend_driver_upperarm, driver_upperarm, n=driver_upperarm + "_0" + str(i + 1) + "_PtCnst", mo=True, w=1) cmds.orientConstraint(blend_driver_lowerarm, driver_lowerarm, n=driver_lowerarm + "_0" + str(i + 1) + "_OrntCnst", mo=True, w=1) cmds.pointConstraint(blend_driver_lowerarm, driver_lowerarm, n=driver_lowerarm + "_0" + str(i + 1) + "_PtCnst", mo=True, w=1) cmds.orientConstraint(twistCtrl, driver_upperarm_twist, n=driver_upperarm_twist + "_0" + str(i + 1) + "_OrntCnst", mo=True, w=1) cmds.pointConstraint(twistCtrl, driver_upperarm_twist, n=driver_upperarm_twist + "_0" + str(i + 1) + "_PtCnst", mo=True, w=1) # Create a driver_upperarm_twist multiplier to multiply the driver_upperarm_twist values by -.5 to counter rotate the driver_upperarm_twist and driver_upperarm back from the overall limb's driver_upperarm_twist amount. twistMult = cmds.shadingNode("multiplyDivide", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_MDnode") twistMultDrive = cmds.shadingNode( "multiplyDivide", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_Drive_MDnode") twistMultDriveInv = cmds.shadingNode( "multiplyDivide", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_DriveInv_MDnode") twistMultMultiplier = cmds.shadingNode( "multiplyDivide", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_Multiplier_MDnode") twistMultMultiplierInv = cmds.shadingNode( "multiplyDivide", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_MultiplierInv_MDnode") twistReverse = cmds.shadingNode("reverse", asUtility=True, name=blend_driver_upperarm_twist + "_0" + str(i + 1) + "_REVnode") cmds.connectAttr(blend_driver_upperarmParent + ".rotateX", twistMult + ".input1X", force=True) cmds.connectAttr( "Rig_Settings." + name + "UpperarmTwist" + str(i + 1) + "Amount", twistReverse + ".inputX") cmds.connectAttr( "Rig_Settings." + name + "UpperarmTwist" + str(i + 1) + "Amount", twistMultMultiplierInv + ".input1X") cmds.connectAttr(twistReverse + ".outputX", twistMultMultiplier + ".input1X", force=True) cmds.connectAttr(twistMult + ".outputX", twistMultDrive + ".input1X", force=True) cmds.connectAttr(twistMultMultiplier + ".outputX", twistMultDrive + ".input2X", force=True) cmds.connectAttr(twistMult + ".outputX", twistMultDriveInv + ".input1X", force=True) cmds.connectAttr(twistMultMultiplierInv + ".outputX", twistMultDriveInv + ".input2X", force=True) cmds.connectAttr(twistMultDrive + ".outputX", blend_driver_upperarm_twist + ".rotateX", force=True) cmds.connectAttr(twistMultDriveInv + ".outputX", blend_driver_upperarm + ".rotateX", force=True) cmds.setAttr(twistMult + ".input2X", -0.5) cmds.setAttr(twistMult + ".input2X", l=True) cmds.setAttr(twistMultMultiplier + ".input2X", 2) cmds.setAttr(twistMultMultiplierInv + ".input2X", 2) cmds.select(blend_driver_upperarmParent) cmds.parentConstraint(driver_clavicle, rollGrp, mo=True) print ".END Building the " + suffix + " UPPER arm twists---------------------------------------"
def locators(): #root locator root = cmds.spaceLocator(n='loc_root') cmds.move(0, 3, 0) cmds.scale(.5, .5, .5) #hip connection for the legs hipCon = cmds.spaceLocator(n='loc_spine_hip_connect') cmds.move(0, 1.5, -.5) cmds.scale(.5, .5, .5) cmds.parent(hipCon, root) #spine locator body = cmds.spaceLocator(n='loc_spine_body') cmds.move(0, 2, 0) cmds.scale(.5, .5, .5) cmds.parent(body, root) #create and group the left wing locators locGrp = cmds.group(n='Locators_Left_Wing', em=True) cmds.parent(locGrp, root) shoulder = cmds.spaceLocator(n='loc_wing_shoulder') cmds.move(.7, 3.1, 0.05) cmds.scale(.2, .2, .2) cmds.parent(shoulder, locGrp) elbow = cmds.spaceLocator(n='loc_wing_elbow') cmds.move(1.4, 1.7, -.7) cmds.scale(.2, .2, .2) cmds.parent(elbow, locGrp) mid = cmds.spaceLocator(n='loc_wing_mid') cmds.move(2.2, 3.5, .46) cmds.scale(.2, .2, .2) cmds.parent(mid, locGrp) tip = cmds.spaceLocator(n='loc_wing_tip') cmds.move(4.6, 2.6, 0) cmds.parent(tip, locGrp) #duplicate and rename left wing locators for the right side cmds.select(locGrp) cmds.duplicate(n='Locators_Right_Wing', rr=True, rc=False) cmds.scale(-2, 2, 2) #create and group left leg locators locGrp2 = cmds.group(n='Locators_Left_Leg', em=True) cmds.parent(locGrp2, root) leg = cmds.spaceLocator(n='loc_leg') cmds.move(.42, 1.15, -.35) cmds.scale(.5, .5, .5) cmds.parent(leg, locGrp2) knee = cmds.spaceLocator(n='loc_leg_knee') cmds.move(.5, .57, -.15) cmds.scale(.5, .5, .5) cmds.parent(knee, locGrp2) ankle = cmds.spaceLocator(n='loc_leg_ankle') cmds.move(.5, .16, .12) cmds.scale(.5, .5, .5) cmds.parent(ankle, locGrp2) #duplicate and rename left leg locators for the right side cmds.select(locGrp2) cmds.duplicate(n='Locators_Right_Leg', rr=True, rc=True) cmds.scale(-2, 2, 2) print 'locators created'
def testDuplicate(self): '''Duplicate Maya and USD objects.''' # Select two objects, one Maya, one USD. spherePath = ufe.Path(mayaUtils.createUfePathSegment("|pSphere1")) sphereItem = ufe.Hierarchy.createItem(spherePath) sphereHierarchy = ufe.Hierarchy.hierarchy(sphereItem) worldItem = sphereHierarchy.parent() ball35Path = ufe.Path([ mayaUtils.createUfePathSegment("|transform1|proxyShape1"), usdUtils.createUfePathSegment("/Room_set/Props/Ball_35") ]) ball35Item = ufe.Hierarchy.createItem(ball35Path) ball35Hierarchy = ufe.Hierarchy.hierarchy(ball35Item) propsItem = ball35Hierarchy.parent() worldHierarchy = ufe.Hierarchy.hierarchy(worldItem) worldChildrenPre = worldHierarchy.children() propsHierarchy = ufe.Hierarchy.hierarchy(propsItem) propsChildrenPre = propsHierarchy.children() ufe.GlobalSelection.get().append(sphereItem) ufe.GlobalSelection.get().append(ball35Item) # Set the edit target to the layer in which Ball_35 is defined (has a # primSpec, in USD terminology). Otherwise, duplication will not find # a source primSpec to copy. Layers are the (anonymous) session layer, # the root layer, then the Assembly_room_set sublayer. Trying to find # the layer by name is not practical, as it requires the full path # name, which potentially differs per run-time environment. ball35Prim = usdUtils.getPrimFromSceneItem(ball35Item) stage = ball35Prim.GetStage() layer = stage.GetLayerStack()[2] stage.SetEditTarget(layer) cmds.duplicate() # The duplicate command doesn't return duplicated non-Maya UFE objects. # They are in the selection, in the same order as the sources. snIter = iter(ufe.GlobalSelection.get()) sphereDupItem = next(snIter) sphereDupName = str(sphereDupItem.path().back()) ball35DupItem = next(snIter) ball35DupName = str(ball35DupItem.path().back()) worldChildren = worldHierarchy.children() propsChildren = propsHierarchy.children() self.assertEqual(len(worldChildren) - len(worldChildrenPre), 1) self.assertEqual(len(propsChildren) - len(propsChildrenPre), 1) self.assertIn(sphereDupItem, worldChildren) self.assertIn(ball35DupItem, propsChildren) cmds.undo() # The duplicated items should no longer appear in the child list of # their parents. def childrenNames(children): return [str(child.path().back()) for child in children] worldHierarchy = ufe.Hierarchy.hierarchy(worldItem) worldChildren = worldHierarchy.children() propsHierarchy = ufe.Hierarchy.hierarchy(propsItem) propsChildren = propsHierarchy.children() worldChildrenNames = childrenNames(worldChildren) propsChildrenNames = childrenNames(propsChildren) self.assertNotIn(sphereDupName, worldChildrenNames) self.assertNotIn(ball35DupName, propsChildrenNames) # The duplicated items shoudl reappear after a redo cmds.redo() snIter = iter(ufe.GlobalSelection.get()) sphereDupItem = next(snIter) ball35DupItem = next(snIter) worldChildren = worldHierarchy.children() propsChildren = propsHierarchy.children() self.assertEqual(len(worldChildren) - len(worldChildrenPre), 1) self.assertEqual(len(propsChildren) - len(propsChildrenPre), 1) self.assertIn(sphereDupItem, worldChildren) self.assertIn(ball35DupItem, propsChildren) cmds.undo() # The duplicated items should not be assigned to the name of a # deactivated USD item. cmds.select(clear=True) # Delete the even numbered props: evenPropsChildrenPre = propsChildrenPre[0:35:2] for propChild in evenPropsChildrenPre: ufe.GlobalSelection.get().append(propChild) cmds.delete() worldHierarchy = ufe.Hierarchy.hierarchy(worldItem) worldChildren = worldHierarchy.children() propsHierarchy = ufe.Hierarchy.hierarchy(propsItem) propsChildren = propsHierarchy.children() propsChildrenPostDel = propsHierarchy.children() # Duplicate Ball_1 ufe.GlobalSelection.get().append(propsChildrenPostDel[0]) cmds.duplicate() snIter = iter(ufe.GlobalSelection.get()) ballDupItem = next(snIter) ballDupName = str(ballDupItem.path().back()) self.assertNotIn(ballDupItem, propsChildrenPostDel) self.assertNotIn(ballDupName, propsChildrenNames) self.assertEqual(ballDupName, "Ball_36") cmds.undo() # undo duplication cmds.undo() # undo deletion
def makeHeadStreatch(jointCount=5): # -> testing guide if not getHeadStreatchGuide(): return # -> make curve attachCurve = makeAttachCurve() upVectorCurve = mc.duplicate(attachCurve)[0] baseDistanceCurve = mc.duplicate(attachCurve)[0] # -> move up vector curve mc.move(mc.arclen(upVectorCurve, ch=False) / 18, 0, 0, upVectorCurve, r=True) # -> make joints Joints, upLocators = makeAttachJoints(attachCurve, upVectorCurve, jointCount) moreWeghtJnt = mc.createNode('joint') mc.delete(mc.parentConstraint(Joints[0], moreWeghtJnt)) mc.setAttr('%s.radius' % moreWeghtJnt, 1.5) # -> make bend Joints BendJoints = [] for i, jnt in enumerate(Joints): BendJoints.append(mc.createNode('joint')) mc.delete(mc.parentConstraint(jnt, BendJoints[i])) mc.makeIdentity(BendJoints[i], t=True, r=True, s=True, apply=True) if i > 0: mc.parent(BendJoints[i], BendJoints[i - 1]) # -> make streatch #-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ distanceValueNode = mc.arclen(attachCurve, ch=True) baseValueNode = mc.arclen(baseDistanceCurve, ch=True) divdeNode = mc.createNode('multiplyDivide') for attr in ('input2X', 'input1Y', 'input2Z'): mc.connectAttr('%s.arcLength' % distanceValueNode, '%s.%s' % (divdeNode, attr)) for attr in ('input1X', 'input2Y', 'input1Z'): mc.connectAttr('%s.arcLength' % baseValueNode, '%s.%s' % (divdeNode, attr)) mc.setAttr('%s.operation' % divdeNode, 2) for jnt in Joints: for attr in 'XYZ': mc.connectAttr('%s.output%s' % (divdeNode, attr), '%s.scale%s' % (jnt, attr)) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - DisStartLocator = mc.spaceLocator(p=(0, 0, 0))[0] DisEndLocator = mc.spaceLocator(p=(0, 0, 0))[0] DistanceNode = mc.createNode('distanceBetween') DisDivideNode = mc.createNode('multiplyDivide') mc.delete(mc.parentConstraint(BendJoints[0], DisStartLocator)) mc.delete(mc.parentConstraint(BendJoints[-1], DisEndLocator)) mc.connectAttr( '%s.worldPosition[0]' % mc.listRelatives(DisStartLocator, s=True, path=True)[0], '%s.point1' % DistanceNode) mc.connectAttr( '%s.worldPosition[0]' % mc.listRelatives(DisEndLocator, s=True, path=True)[0], '%s.point2' % DistanceNode) mc.connectAttr('%s.distance' % DistanceNode, '%s.input1Y' % DisDivideNode) mc.setAttr('%s.input2Y' % DisDivideNode, mc.getAttr('%s.input1Y' % DisDivideNode)) mc.setAttr('%s.operation' % DisDivideNode, 2) for jnt in BendJoints: mc.connectAttr('%s.outputY' % DisDivideNode, '%s.sy' % jnt) #-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ # -> Rig # - bend joints - #BendIKHandle = mc.ikHandle(sj=BendJoints[0], ee=BendJoints[1]) VectorLoc = mc.spaceLocator(p=(0, 0, 0))[0] mc.delete(mc.parentConstraint(Joints[0], VectorLoc)) mc.move(mc.arclen(upVectorCurve, ch=False) / 18, 0, 0, VectorLoc, r=True) for i, jnt in enumerate(BendJoints): if i > 0: mc.connectAttr('%s.rotate' % BendJoints[0], '%s.rotate' % jnt) # - skin bind Curve - mc.skinCluster(BendJoints, attachCurve) mc.skinCluster(BendJoints, upVectorCurve) # - make Cotrol - localStartControl = mc.circle(nr=(0, 1, 0), ch=False)[0] localEndControl = mc.circle(nr=(0, 1, 0), ch=False)[0] localStartControlGrp = mc.group(localStartControl) localEndControlGrp = mc.group(localEndControl) startControl = mc.circle(nr=(0, 1, 0), ch=False)[0] endControl = mc.circle(nr=(0, 1, 0), ch=False)[0] startControlGrp = mc.group(startControl) endControlGrp = mc.group(endControl) # - match position - mc.delete(mc.parentConstraint(Joints[0], localStartControlGrp)) mc.delete(mc.parentConstraint(Joints[-1], localEndControlGrp)) mc.delete(mc.parentConstraint(Joints[0], startControlGrp)) mc.delete(mc.parentConstraint(Joints[-1], endControlGrp)) # - add Attribute - mc.addAttr(endControl, ln='range', min=0, max=3, dv=1) mc.setAttr('%s.range' % endControl, k=False, cb=True) # - connect - for i, attr in enumerate( ('tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v')): mc.connectAttr('%s.%s' % (startControl, attr), '%s.%s' % (localStartControl, attr)) if i < 3: multiNode = mc.createNode('multDoubleLinear') mc.connectAttr('%s.%s' % (endControl, attr), '%s.input1' % multiNode) mc.connectAttr('%s.range' % endControl, '%s.input2' % multiNode) mc.connectAttr('%s.output' % multiNode, '%s.%s' % (localEndControl, attr)) else: mc.connectAttr('%s.%s' % (endControl, attr), '%s.%s' % (localEndControl, attr)) if i > 2: mc.setAttr('%s.%s' % (startControl, attr), l=True, k=False) mc.setAttr('%s.%s' % (endControl, attr), l=True, k=False) # - constraint - mc.pointConstraint(localStartControl, BendJoints[0]) mc.aimConstraint(localEndControl, BendJoints[0], aim=(0, 1, 0), wu=(1, 0, 0), wuo=VectorLoc, wut='object') # -> Compile JointGrp = mc.group(Joints, moreWeghtJnt) LocatorGrp = mc.group(upLocators) CurveGrp = mc.group(attachCurve, upVectorCurve, baseDistanceCurve) BendJointGrp = mc.group(BendJoints[0]) controlGrp = mc.group(startControlGrp, endControlGrp) localControlGrp = mc.group(localStartControlGrp, localEndControlGrp) setGrp = mc.group(JointGrp, BendJointGrp, LocatorGrp, CurveGrp) rootGrp = mc.group(controlGrp, localControlGrp, setGrp) mc.parent(DisStartLocator, localStartControl) mc.parent(DisEndLocator, localEndControl) mc.parent(VectorLoc, localStartControl) # -> rename # - bend set - DisStartLocator = mc.rename(DisStartLocator, 'C_HSbendDisStart_loc_0') DisEndLocator = mc.rename(DisEndLocator, 'C_HSbendDisEnd_loc_0') for i, jnt in enumerate(BendJoints): BendJoints[i] = mc.rename(jnt, 'C_HSbend%s_jnt_0' % string.uppercase[i]) BendJointGrp = mc.rename(BendJointGrp, 'C_HSbendJoint_jnh_0') VectorLoc = mc.rename(VectorLoc, 'C_HSBendVector_loc_0') # - joint - for i, jnt in enumerate(Joints): Joints[i] = mc.rename(jnt, 'C_headStreatch%s_bnd_0' % string.uppercase[i]) moreWeghtJnt = mc.rename(moreWeghtJnt, 'C_headStreatch_bnd_0') JointGrp = mc.rename(JointGrp, 'C_headStreatch_bndG_0') # - locator - for i, loc in enumerate(upLocators): upLocators[i] = mc.rename( loc, 'C_headStreatchUp%s_loc_0' % string.uppercase[i]) mc.rename(LocatorGrp, 'C_headStreatch_locG_0') # - control - startControl = mc.rename(startControl, 'C_HSstart_ctl_0') endControl = mc.rename(endControl, 'C_HSend_ctl_0') startControlGrp = mc.rename(startControlGrp, 'C_HSstart_cth_0') endControlGrp = mc.rename(endControlGrp, 'C_HSend_cth_0') localStartControl = mc.rename(localStartControl, 'C_HSstartLocal_ctl_0') localEndControl = mc.rename(localEndControl, 'C_HSendLocal_ctl_0') localStartControlGrp = mc.rename(localStartControlGrp, 'C_HSstartLocal_cth_0') localEndControlGrp = mc.rename(localEndControlGrp, 'C_HSendLocal_cth_0') controlGrp = mc.rename(controlGrp, 'C_headStreatch_cth_0') localControlGrp = mc.rename(localControlGrp, 'C_headStreatchLocal_cth_0') # - curve - attachCurve = mc.rename(attachCurve, 'C_HSJointAttach_cus_0') upVectorCurve = mc.rename(upVectorCurve, 'C_HSLocatorAttach_cus_0') baseDistanceCurve = mc.rename(baseDistanceCurve, 'C_HSDistance_cus_0') mc.rename(CurveGrp, 'C_HeadStreatch_cusgrp_0') # - comp group - mc.rename(setGrp, 'C_headStreatch_setg_0') mc.rename(rootGrp, 'C_headStreatch_grp_0') # -> clean up mc.hide(upLocators) mc.hide(upVectorCurve, baseDistanceCurve) mc.hide(localControlGrp) mc.hide(BendJointGrp) mc.setAttr('%s.template' % attachCurve, 1) # -> create selection sets mc.sets(Joints, moreWeghtJnt, name='C_HSJoint_set_0') mc.sets(startControl, endControl, name='C_HSControl_set_0')
def recreateJoints(): if not cmds.objExists("loc_Grp_1"): print "You must generate a skeleton first!" else: locList = [] cmds.duplicate("loc_Grp_1", rc=True) locsDup = [] cmds.group(n="loc_Grp_dup", em=True) for pc in cmds.listRelatives("loc_Grp_2", ad=True): if "parentConstraint2" in pc: cmds.delete(pc) else: print "didnt find pc" if "Shape" in pc: print "this is shape" else: locsDup.append(pc) cmds.parent(pc, "loc_Grp_dup") for loc in cmds.listRelatives("loc_Grp_dup"): cmds.select(loc) for item in pm.selected(): if "tail" in loc: print "skippy" elif "4" in item: item.rename(item.name().replace('4', '11')) elif "5" in loc: item.rename(item.name().replace('5', '21')) elif "6" in loc: item.rename(item.name().replace('6', '31')) else: print "nope" ''' if item == "loc_spine11": item.rename(item.name().replace('11','21')) if item == "loc_spine3": item.rename(item.name().replace('spine3','spine11')) ''' cmds.delete("loc_Grp_2") cmds.group(n="new_dup_Grp", em=True) for i in cmds.listRelatives("loc_Grp_dup"): #aimLocs = cmds.listRelatives(i,p=1) #aimLocsPar = cmds.listRelatives(i,p=1) if "L_" in i: print i new_dup = cmds.duplicate(i, n=i + "moved") cmds.parent(new_dup, 'new_dup_Grp') cmds.xform(os=True, r=True, t=(0, 1, 0)) for obj in cmds.listRelatives("loc_Grp_1", ad=True, type="locator"): #print obj locs = cmds.listRelatives(obj, p=1) locsPar = cmds.listRelatives(locs, p=True) #print locs[0] + " is the child" #print locsPar[0] + " is the parent" if locs[0] == "loc_root_joint": locList.append(locs[0]) elif locs[0] == "loc_Grp_1": print locs[0] elif locsPar[0] == "loc_Grp_1": print locsPar[0] else: if "11" in locs[0] or "11" in locsPar[0]: print "no par" elif not cmds.objExists(locs[0] + "1") or not cmds.objExists(locsPar[0] + "1"): print "no exists" else: if "L_" not in locs[0] or "L_" not in locsPar[0]: print "THIS IS THE FLAG YOURE LOOKING FOR : " + locs[ 0] + " ----->" + locsPar[0] #aimToDel = cmds.aimConstraint(locs[0] + "1",locsPar[0] + "1",wuo=locs[0] + "1" + "moved") #cmds.delete(aimToDel) cmds.parent(locs[0] + "1", locsPar[0] + "1") locList.append(locs[0]) elif "hand" in locsPar[0]: print "THIS IS THE HAND : " + locsPar[0] cmds.parent(locs[0] + "1", locsPar[0] + "1") locList.append(locs[0]) else: print "THIS IS THE FLAG SAYING NOT L : " + locs[ 0] + "=====>" + locsPar[0] aimToDel = cmds.aimConstraint(locs[0] + "1", locsPar[0] + "1", wuo=locsPar[0] + "1" + "moved", u=(0, 1, 0), aim=(1, 0, 0), wut="object") cmds.delete(aimToDel) cmds.parent(locs[0] + "1", locsPar[0] + "1") locList.append(locs[0]) cmds.delete('new_dup_Grp') jointGroup = [] newLocList = [] newJointList = [] counterJoint = 1 newJointGroup = cmds.group(n="joint_group", em=True) ''' for locator in locList: print locator if "_R_" in locator: print "bad loc" else: if locator not in newLocList: print locator newLocList.append(locator) else: print " its in list" ''' posture = '' for fix in cmds.listRelatives("loc_Grp_dup", ad=True, type="locator"): fixNew = cmds.listRelatives(fix, p=True) newLocList.append(fixNew) if "hock" in str(newLocList): posture = "quadruped" elif "hock" not in str(newLocList): print "asd" posture = "biped" print locList print newLocList for l in newLocList: print "JUST STARTESDFSJDGSDFJG" print l cmds.select(cl=True) locPos = [] locRot = [] locPos.append(cmds.xform(l, q=True, ws=True, t=True)) locRot.append(cmds.xform(l, q=True, ws=True, ro=True)) newJoint = cmds.joint(n="joint_" + l[0], p=locPos[0], o=locRot[0]) jointGroup.append(newJoint) print "just made " + newJoint newJointList.append(newJoint) cmds.parent(newJoint, newJointGroup) print "just parented " + newJoint + " to : " + newJointGroup for jtl in newLocList: getJointParent = cmds.listRelatives(jtl, p=True) print getJointParent[0] + " THIS IS THE PARENT" print jtl[0] + " THIS IS THE CHILD" if not getJointParent: print "no parent" else: properJointParent = "joint_" + getJointParent[-1] properJointChild = newJointList[counterJoint] if "joint_loc_Grp_dup" in properJointParent or "joint_loc_Grp_dup" in properJointChild: print "top of chain" else: print "it dont work" print properJointChild + " ch" print properJointParent + " par" cmds.parent(properJointChild, properJointParent, a=True) counterJoint += 1 print posture if posture == "biped": shoulderNames = ["clav"] else: shoulderNames = ["clav", "shoulder"] thighNames = ["thigh", "hip"] for jx in newLocList: print jx[0] jxPar = cmds.listRelatives(jx[0], p=True) if ("_L_" in jx[0] or "L_" in jx[0]) and ("_L_" not in jxPar or "L_" not in jxPar): for name in shoulderNames: if name in jx[0]: clav_mirror = cmds.select("joint_" + jx[0]) sel = cmds.ls(sl=True) cmds.mirrorJoint(clav_mirror, mb=True, myz=True, sr=("L_", "R_")) for oName in thighNames: if oName in jx[0]: thigh_mirror = cmds.select("joint_" + jx[0]) sel = cmds.ls(sl=True) cmds.mirrorJoint(thigh_mirror, mb=True, myz=True, sr=("L_", "R_")) else: print "not right" #cmds.mirrorJoint(clav_mirror,mb=True, myz=True, sr = ("L_","R_")) #thigh_mirror = cmds.select("joint_loc_L_thigh_joint1") #cmds.mirrorJoint(thigh_mirror,mb=True, myz=True, sr = ("L_","R_")) cmds.delete("loc_Grp_1") cmds.delete("obj_group_1") cmds.delete("loc_Grp_dup") cmds.select('joint_loc_root_joint1') print "THIS IS THE NEW SCRIPT!!!!!!!"
# Importing the Maya command set. import maya.cmds as cmds # Creating snowman base cmds.polySphere(r=True, sx=20, sy=20, ax=[0, 1, 0], cuv=2, ch=1) # Result: pSphere1 polySphere1 # cmds.duplicate(rr=True) # Result: pSphere2 # cmds.move(0, 1.831615, 0, r=True, os=True, wd=True) cmds.scale(0.687349, 0.687349, 0.687349, r=True) cmds.move(0, -0.244511, 0, r=True, os=True, wd=True) cmds.duplicate(rr=True) # Result: pSphere3 # cmds.move(0, 1.1459, 0, r=True, os=True, wd=True) cmds.scale(0.758657, 0.758657, 0.758657, r=True) cmds.move(0, -0.127419, 0, r=True, os=True, wd=True) cmds.select('pSphere2', tgl=True) cmds.move(0, -0.245208, 0, r=True, os=True, wd=True) cmds.select(clear=True) cmds.select('pSphere1', r=True) cmds.scale(0.91359, 0.91359, 0.91359, r=True) cmds.move(0, 0.123063, 0, r=True, os=True, wd=True) cmds.scale(0.946528, 0.946528, 0.946528, r=True) cmds.select('pSphere2', r=True) cmds.scale(1.03269, 1.03269, 1.03269, r=True) cmds.select(clear=True) # Creating the eyes cmds.select('pSphere3', r=True) cmds.duplicate(rr=True) # Result: pSphere4 #
import sys sys.path.append(r"C:\Program Files\Autodesk\Maya2016\Python\Lib\site-packages") from os.path import join from maya.standalone import initialize import maya.cmds as cmds import maya.mel as mel initialize("python") origPath = "H:/Windows/Desktop/headlessTest.ma" cmds.file(origPath, open=True) mySphere = "pSphere1" cmds.duplicate(mySphere) cmds.xform(mySphere, ws=True, t=(3, 3, 3)) newName = "NEWTEST.ma" path = join("H:/Windows/Desktop", newName) fileName = cmds.file(rename=path) cmds.file(s=True)
def sqGenerateCurves(self, *args): self.edgeList = cmds.ls(selection=True, flatten=True) if not self.edgeList == None and not self.edgeList == [] and not self.edgeList == "": self.baseCurve = cmds.polyToCurve(name="baseCurve", form=2, degree=1)[0] cmds.select(self.baseCurve + ".ep[*]") cmds.insertKnotCurve(cmds.ls(selection=True, flatten=True), constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True) pointListA, pointListB, sideA, sideB = self.sqGetPointLists() toDeleteList = [] p = 2 for k in range((sideA + 2), (sideB - 1)): if p % 2 == 0: toDeleteList.append(self.baseCurve + ".cv[" + str(k) + "]") toDeleteList.append(self.baseCurve + ".cv[" + str(k + len(pointListA) - 1) + "]") p = p + 1 q = 2 m = sideA - 2 if m >= 0: while m >= 0: if not m == sideA and not m == sideB: if q % 2 == 0: toDeleteList.append(self.baseCurve + ".cv[" + str(m) + "]") m = m - 1 q = q + 1 cmds.delete(toDeleteList) cmds.insertKnotCurve([ self.baseCurve + ".u[" + str(len(pointListA) - 1) + "]", self.baseCurve + ".ep[" + str(len(pointListA) - 1) + "]" ], constructionHistory=True, curveOnSurface=True, numberOfKnots=1, addKnots=False, insertBetween=True, replaceOriginal=True) pointListA, pointListB, sideA, sideB = self.sqGetPointLists() posListA, posListB = [], [] for i in range(0, len(pointListA) - 1): posListA.append( cmds.xform(pointListA[i], query=True, worldSpace=True, translation=True)) posListB.append( cmds.xform(pointListB[i], query=True, worldSpace=True, translation=True)) self.mainCurveA = cmds.curve(name="StickyLips_Main_A_Crv", degree=1, point=posListA) self.mainCurveB = cmds.curve(name="StickyLips_Main_B_Crv", degree=1, point=posListB) cmds.rename( cmds.listRelatives(self.mainCurveA, children=True, shapes=True)[0], self.mainCurveA + "Shape") cmds.rename( cmds.listRelatives(self.mainCurveB, children=True, shapes=True)[0], self.mainCurveB + "Shape") cmds.select(self.mainCurveA + ".cv[*]") self.curveLenght = len(cmds.ls(selection=True, flatten=True)) cmds.select(clear=True) self.sqCheckCurveDirection(self.mainCurveA) self.sqCheckCurveDirection(self.mainCurveB) self.baseCurveA = cmds.duplicate(self.mainCurveA, name=self.mainCurveA.replace( "_Main_", "_Base_"))[0] self.baseCurveB = cmds.duplicate(self.mainCurveB, name=self.mainCurveB.replace( "_Main_", "_Base_"))[0] cmds.delete(self.baseCurve) self.maxIter = len(posListA) cmds.group(self.mainCurveA, self.mainCurveB, self.baseCurveA, self.baseCurveB, name="StickyLips_StaticData_Grp") else: mel.eval("warning \"Please, select an closed edgeLoop.\";")
def invert(base=None, corrective=None, name=None): """Inverts a shape through the deformation chain. @param[in] base Deformed base mesh. @param[in] corrective Sculpted corrective mesh. @param[in] name Name of the generated inverted shape. @return The name of the inverted shape. """ cmds.loadPlugin('cvshapeinverter_plugin.py', qt=True) if not base or not corrective: sel = cmds.ls(sl=True) if not sel or len(sel) != 2: cmds.undoInfo(closeChunk=True) raise RuntimeError, 'Select base then corrective' base, corrective = sel # Get points on base mesh base_points = get_points(base) point_count = base_points.length() # Get points on corrective mesh corrective_points = get_points(corrective) # Get the intermediate mesh orig_mesh = get_shape(base, intermediate=True) # Get the component offset axes orig_points = get_points(orig_mesh) x_points = OpenMaya.MPointArray(orig_points) y_points = OpenMaya.MPointArray(orig_points) z_points = OpenMaya.MPointArray(orig_points) cmds.undoInfo(openChunk=True) for i in range(point_count): x_points[i].x += 1.0 y_points[i].y += 1.0 z_points[i].z += 1.0 set_points(orig_mesh, x_points) x_points = get_points(base) set_points(orig_mesh, y_points) y_points = get_points(base) set_points(orig_mesh, z_points) z_points = get_points(base) set_points(orig_mesh, orig_points) # Create the mesh to get the inversion deformer if not name: name = '%s_inverted' % corrective inverted_shapes = cmds.duplicate(base, name=name)[0] # Delete the unnessary shapes shapes = cmds.listRelatives(inverted_shapes, children=True, shapes=True, path=True) for s in shapes: if cmds.getAttr('%s.intermediateObject' % s): cmds.delete(s) set_points(inverted_shapes, orig_points) # Unlock the transformation attrs for attr in 'trs': for x in 'xyz': cmds.setAttr('%s.%s%s' % (inverted_shapes, attr, x), lock=False) cmds.setAttr('%s.visibility' % inverted_shapes, 1) deformer = cmds.deformer(inverted_shapes, type='cvShapeInverter')[0] # Calculate the inversion matrices deformer_mobj = get_mobject(deformer) fn_deformer = OpenMaya.MFnDependencyNode(deformer_mobj) plug_matrix = fn_deformer.findPlug('inversionMatrix', False) fn_matrix_data = OpenMaya.MFnMatrixData() for i in range(point_count): matrix = OpenMaya.MMatrix() set_matrix_row(matrix, x_points[i] - base_points[i], 0) set_matrix_row(matrix, y_points[i] - base_points[i], 1) set_matrix_row(matrix, z_points[i] - base_points[i], 2) set_matrix_row(matrix, corrective_points[i], 3) matrix = matrix.inverse() matrix_mobj = fn_matrix_data.create(matrix) plug_matrixElement = plug_matrix.elementByLogicalIndex(i) plug_matrixElement.setMObject(matrix_mobj) # Store the base points. fn_point_data = OpenMaya.MFnPointArrayData() point_data_mobj = fn_point_data.create(base_points) plug_deformed_points = fn_deformer.findPlug('deformedPoints', False) plug_deformed_points.setMObject(point_data_mobj) cmds.connectAttr('%s.outMesh' % get_shape(corrective), '%s.correctiveMesh' % deformer) cmds.undoInfo(closeChunk=True) return inverted_shapes
def rigModule(self, *args): Base.StartClass.rigModule(self) # verify if the guide exists: if cmds.objExists(self.moduleGrp): try: hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True) except: hideJoints = 1 # create lists to be integrated: # start as no having mirror: sideList = [""] # analisys the mirror module: self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis") if self.mirrorAxis != 'off': # get rigs names: self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName") # get first and last letters to use as side initials (prefix): sideList = [ self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_' ] for s, side in enumerate(sideList): duplicated = cmds.duplicate( self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, side + self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True) cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True) # re-rename grp: cmds.rename( self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp) # do a group mirror with negative scaling: if s == 1: for axis in self.mirrorAxis: cmds.setAttr( side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1) # joint labelling: jointLabelAdd = 1 else: # if not mirror: duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0] allGuideList = cmds.listRelatives(duplicated, allDescendents=True) for item in allGuideList: cmds.rename(item, self.userGuideName + "_" + item) self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True) # re-rename grp: cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp) # joint labelling: jointLabelAdd = 0 # store the number of this guide by module type dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1 # run for all sides for s, side in enumerate(sideList): # redeclaring variables: self.base = side + self.userGuideName + "_Guide_Base" self.cvFootLoc = side + self.userGuideName + "_Guide_Foot" self.cvRFALoc = side + self.userGuideName + "_Guide_RfA" self.cvRFBLoc = side + self.userGuideName + "_Guide_RfB" self.cvRFCLoc = side + self.userGuideName + "_Guide_RfC" self.cvRFDLoc = side + self.userGuideName + "_Guide_RfD" self.cvRFELoc = side + self.userGuideName + "_Guide_RfE" self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd" # declaring attributes reading from dictionary: ankleRFAttr = self.langDic[self.langName]['c009_leg_extrem'] middleRFAttr = self.langDic[ self.langName]['c017_RevFoot_middle'] outsideRFAttr = self.langDic[self.langName]['c010_RevFoot_A'] insideRFAttr = self.langDic[self.langName]['c011_RevFoot_B'] heelRFAttr = self.langDic[self.langName]['c012_RevFoot_C'] toeRFAttr = self.langDic[self.langName]['c013_RevFoot_D'] ballRFAttr = self.langDic[self.langName]['c014_RevFoot_E'] footRFAttr = self.langDic[self.langName]['c015_RevFoot_F'] sideRFAttr = self.langDic[self.langName]['c016_RevFoot_G'] rfRoll = self.langDic[ self.langName]['c018_RevFoot_roll'].capitalize() rfSpin = self.langDic[ self.langName]['c019_RevFoot_spin'].capitalize() rfTurn = self.langDic[ self.langName]['c020_RevFoot_turn'].capitalize() rfAngle = self.langDic[ self.langName]['c102_angle'].capitalize() rfPlant = self.langDic[ self.langName]['c103_plant'].capitalize() showCtrlsAttr = self.langDic[ self.langName]['c021_showControls'] # creating joints: cmds.select(clear=True) self.footJnt = cmds.joint(name=side + self.userGuideName + "_" + ankleRFAttr.capitalize() + "_Jnt") utils.setJointLabel( self.footJnt, s + jointLabelAdd, 18, self.userGuideName + "_" + ankleRFAttr.capitalize()) self.middleFootJxt = cmds.joint( name=side + self.userGuideName + "_" + middleRFAttr.capitalize() + "_Jxt") self.endJnt = cmds.joint(name=side + self.userGuideName + "_JEnd") cmds.select(clear=True) self.middleFootJnt = cmds.joint( name=side + self.userGuideName + "_" + middleRFAttr.capitalize() + "_Jnt") utils.setJointLabel( self.middleFootJnt, s + jointLabelAdd, 18, self.userGuideName + "_" + middleRFAttr.capitalize()) self.endBJnt = cmds.joint(name=side + self.userGuideName + "B_JEnd") cmds.parent(self.middleFootJnt, self.middleFootJxt) cmds.addAttr(self.footJnt, longName='dpAR_joint', attributeType='float', keyable=False) cmds.addAttr(self.middleFootJnt, longName='dpAR_joint', attributeType='float', keyable=False) cmds.select(clear=True) ''' Deactivate the segment scale compensate on the bone to prevent scaling problem in maya 2016 It will prevent a double scale problem that will come from the upper parent in the rig ''' if (int(cmds.about(version=True)[:4]) >= 2016): cmds.setAttr(self.footJnt + ".segmentScaleCompensate", 0) cmds.setAttr( self.middleFootJxt + ".segmentScaleCompensate", 0) cmds.setAttr( self.middleFootJnt + ".segmentScaleCompensate", 0) # reverse foot controls: self.RFACtrl = self.ctrls.cvControl( "id_018_FootReverse", side + self.userGuideName + "_" + outsideRFAttr.capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.1), d=self.curveDegree) self.RFBCtrl = self.ctrls.cvControl( "id_018_FootReverse", side + self.userGuideName + "_" + insideRFAttr.capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.1), d=self.curveDegree) self.RFCCtrl = self.ctrls.cvControl( "id_018_FootReverse", side + self.userGuideName + "_" + heelRFAttr.capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.1), d=self.curveDegree, dir="+Y", rot=(0, 90, 0)) self.RFDCtrl = self.ctrls.cvControl( "id_018_FootReverse", side + self.userGuideName + "_" + toeRFAttr.capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.1), d=self.curveDegree, dir="+Y", rot=(0, 90, 0)) self.RFECtrl = self.ctrls.cvControl( "id_019_FootReverseE", side + self.userGuideName + "_" + ballRFAttr.capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.1), d=self.curveDegree, rot=(0, 90, 0)) # reverse foot groups: self.RFAGrp = cmds.group(self.RFACtrl, name=self.RFACtrl + "_Grp") self.RFBGrp = cmds.group(self.RFBCtrl, name=self.RFBCtrl + "_Grp") self.RFCGrp = cmds.group(self.RFCCtrl, name=self.RFCCtrl + "_Grp") self.RFDGrp = cmds.group(self.RFDCtrl, name=self.RFDCtrl + "_Grp") self.RFEGrp = cmds.group(self.RFECtrl, name=self.RFECtrl + "_Grp") rfGrpList = [ self.RFAGrp, self.RFBGrp, self.RFCGrp, self.RFDGrp, self.RFEGrp ] self.ballRFList.append(self.RFEGrp) # putting groups in the correct place: tempToDelA = cmds.parentConstraint(self.cvFootLoc, self.footJnt, maintainOffset=False) tempToDelB = cmds.parentConstraint(self.cvRFELoc, self.middleFootJxt, maintainOffset=False) tempToDelC = cmds.parentConstraint(self.cvEndJoint, self.endJnt, maintainOffset=False) tempToDelD = cmds.parentConstraint(self.cvEndJoint, self.endBJnt, maintainOffset=False) tempToDelE = cmds.parentConstraint(self.cvRFALoc, self.RFAGrp, maintainOffset=False) tempToDelF = cmds.parentConstraint(self.cvRFBLoc, self.RFBGrp, maintainOffset=False) tempToDelG = cmds.parentConstraint(self.cvRFCLoc, self.RFCGrp, maintainOffset=False) tempToDelH = cmds.parentConstraint(self.cvRFDLoc, self.RFDGrp, maintainOffset=False) tempToDelI = cmds.parentConstraint(self.cvRFELoc, self.RFEGrp, maintainOffset=False) cmds.delete(tempToDelA, tempToDelB, tempToDelC, tempToDelD, tempToDelE, tempToDelF, tempToDelG, tempToDelH, tempToDelI) # mounting hierarchy: cmds.parent(self.RFBGrp, self.RFACtrl) cmds.parent(self.RFCGrp, self.RFBCtrl) cmds.parent(self.RFDGrp, self.RFCCtrl) cmds.parent(self.RFEGrp, self.RFDCtrl) # reverse foot zero out groups: self.RFEZero = utils.zeroOut([self.RFEGrp])[0] self.RFEZeroExtra = utils.zeroOut([self.RFEZero])[0] self.RFDZero = utils.zeroOut([self.RFDGrp])[0] self.RFCZero = utils.zeroOut([self.RFCGrp])[0] self.RFBZero = utils.zeroOut([self.RFBGrp])[0] self.RFAZero = utils.zeroOut([self.RFAGrp])[0] self.RFAZeroExtra = utils.zeroOut([self.RFAZero])[0] rfJointZeroList = [ self.RFAZero, self.RFBZero, self.RFCZero, self.RFDZero, self.RFEZero ] # fixing side rool rotation order: cmds.setAttr(self.RFBZero + ".rotateOrder", 5) # creating ikHandles: ikHandleAnkleList = cmds.ikHandle( name=side + self.userGuideName + "_" + ankleRFAttr.capitalize() + "_IkHandle", startJoint=self.footJnt, endEffector=self.middleFootJxt, solver='ikSCsolver') ikHandleMiddleList = cmds.ikHandle( name=side + self.userGuideName + "_" + middleRFAttr.capitalize() + "_IkHandle", startJoint=self.middleFootJxt, endEffector=self.endJnt, solver='ikSCsolver') cmds.rename(ikHandleAnkleList[1], ikHandleAnkleList[0] + "_Effector") cmds.rename(ikHandleMiddleList[1], ikHandleMiddleList[0] + "_Effector") cmds.setAttr(ikHandleAnkleList[0] + '.visibility', 0) cmds.setAttr(ikHandleMiddleList[0] + '.visibility', 0) # creating Fk controls: self.footCtrl = self.ctrls.cvControl( "id_020_FootFk", side + self.userGuideName + "_" + self.langDic[self.langName]['c009_leg_extrem'] + "_Ctrl", r=(self.ctrlRadius * 0.5), d=self.curveDegree, dir="+Z") self.footCtrlList.append(self.footCtrl) cmds.setAttr(self.footCtrl + ".rotateOrder", 1) self.revFootCtrlShapeList.append( cmds.listRelatives(self.footCtrl, children=True, type='nurbsCurve')[0]) self.middleFootCtrl = self.ctrls.cvControl( "id_021_FootMiddle", side + self.userGuideName + "_" + self.langDic[ self.langName]['c017_RevFoot_middle'].capitalize() + "_Ctrl", r=(self.ctrlRadius * 0.5), d=self.curveDegree) cmds.setAttr(self.middleFootCtrl + '.overrideEnabled', 1) cmds.setAttr(self.middleFootCtrl + ".rotateOrder", 4) tempToDelA = cmds.parentConstraint(self.cvFootLoc, self.footCtrl, maintainOffset=False) tempToDelB = cmds.parentConstraint(self.cvRFELoc, self.middleFootCtrl, maintainOffset=False) cmds.delete(tempToDelA, tempToDelB) if s == 1: cmds.setAttr(self.middleFootCtrl + ".scaleX", -1) cmds.setAttr(self.middleFootCtrl + ".scaleY", -1) cmds.setAttr(self.middleFootCtrl + ".scaleZ", -1) self.footCtrlZeroList = utils.zeroOut( [self.footCtrl, self.middleFootCtrl]) self.middleFootCtrlList.append(self.middleFootCtrl) # mount hierarchy: cmds.parent(self.footCtrlZeroList[1], self.RFDCtrl, absolute=True) cmds.parent(ikHandleMiddleList[0], self.middleFootCtrl, absolute=True) self.toLimbIkHandleGrp = cmds.group( empty=True, name=side + self.userGuideName + "_" + self.langDic[self.langName]['c009_leg_extrem'] + "_Grp") self.toLimbIkHandleGrpList.append(self.toLimbIkHandleGrp) cmds.parent(ikHandleAnkleList[0], self.toLimbIkHandleGrp, self.RFECtrl, absolute=True) cmds.makeIdentity(self.toLimbIkHandleGrp, apply=True, translate=True, rotate=True, scale=True) parentConst = cmds.parentConstraint(self.RFECtrl, self.footJnt, maintainOffset=True, name=self.footJnt + "_ParentConstraint")[0] self.parentConstList.append(parentConst) self.footJntList.append(self.footJnt) cmds.parent(self.RFAZeroExtra, self.footCtrl, absolute=True) scaleConst = cmds.scaleConstraint(self.footCtrl, self.footJnt, maintainOffset=True, name=self.footJnt + "_ScaleConstraint") self.scaleConstList.append(scaleConst) cmds.parentConstraint(self.middleFootCtrl, self.middleFootJnt, maintainOffset=True, name=self.middleFootJnt + "_ParentConstraint") cmds.scaleConstraint(self.middleFootCtrl, self.middleFootJnt, maintainOffset=True, name=self.middleFootJnt + "_ScaleConstraint") # add attributes to footCtrl and connect them to reverseFoot groups rotation: rfAttrList = [ outsideRFAttr, insideRFAttr, heelRFAttr, toeRFAttr, ballRFAttr ] rfTypeAttrList = [rfRoll, rfSpin] for j, rfAttr in enumerate(rfAttrList): for t, rfType in enumerate(rfTypeAttrList): if t == 1 and j == (len(rfAttrList) - 1): # create turn attr to ball cmds.addAttr(self.footCtrl, longName=rfAttr + rfTurn, attributeType='float', keyable=True) cmds.connectAttr(self.footCtrl + "." + rfAttr + rfTurn, rfGrpList[j] + ".rotateZ", force=True) self.reverseFootAttrList.append(rfAttr + rfTurn) cmds.addAttr(self.footCtrl, longName=rfAttr + rfType, attributeType='float', keyable=True) self.reverseFootAttrList.append(rfAttr + rfType) if t == 0: if j > 1: cmds.connectAttr(self.footCtrl + "." + rfAttr + rfType, rfGrpList[j] + ".rotateX", force=True) else: cmds.connectAttr(self.footCtrl + "." + rfAttr + rfType, rfGrpList[j] + ".rotateZ", force=True) else: cmds.connectAttr(self.footCtrl + "." + rfAttr + rfType, rfGrpList[j] + ".rotateY", force=True) # creating the originedFrom attributes (in order to permit integrated parents in the future): utils.originedFrom(objName=self.footCtrl, attrString=self.base + ";" + self.cvFootLoc + ";" + self.cvRFALoc + ";" + self.cvRFBLoc + ";" + self.cvRFCLoc + ";" + self.cvRFDLoc) utils.originedFrom(objName=self.middleFootCtrl, attrString=self.cvRFELoc + ";" + self.cvEndJoint) # creating pre-defined attributes for footRoll and sideRoll attributes, also rollAngle: cmds.addAttr(self.footCtrl, longName=footRFAttr + rfRoll, attributeType='float', keyable=True) cmds.addAttr(self.footCtrl, longName=footRFAttr + rfRoll + rfAngle, attributeType='float', defaultValue=30, keyable=True) cmds.addAttr(self.footCtrl, longName=footRFAttr + rfRoll + rfPlant, attributeType='float', defaultValue=0, keyable=True) cmds.addAttr(self.footCtrl, longName=sideRFAttr + rfRoll, attributeType='float', keyable=True) # create clampNodes in order to limit the side rotations: sideClamp = cmds.createNode("clamp", name=side + self.userGuideName + "_Side_Clp") # outside values in R cmds.setAttr(sideClamp + ".minR", -360) # inside values in G cmds.setAttr(sideClamp + ".maxG", 360) # inverting sideRoll values: sideMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_Side_MD") cmds.setAttr(sideMD + ".input2X", -1) # connections: cmds.connectAttr(self.footCtrl + "." + sideRFAttr + rfRoll, sideMD + ".input1X", force=True) cmds.connectAttr(sideMD + ".outputX", sideClamp + ".inputR", force=True) cmds.connectAttr(sideMD + ".outputX", sideClamp + ".inputG", force=True) cmds.connectAttr(sideClamp + ".outputR", self.RFAZero + ".rotateZ", force=True) cmds.connectAttr(sideClamp + ".outputG", self.RFBZero + ".rotateZ", force=True) # for footRoll: footHeelClp = cmds.createNode("clamp", name=side + self.userGuideName + "_Roll_Heel_Clp") # heel values in R cmds.setAttr(footHeelClp + ".minR", -360) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, footHeelClp + ".inputR", force=True) cmds.connectAttr(footHeelClp + ".outputR", self.RFCZero + ".rotateX", force=True) # footRoll with angle limit: footPMA = cmds.createNode("plusMinusAverage", name=side + self.userGuideName + "_Roll_PMA") footSR = cmds.createNode("setRange", name=side + self.userGuideName + "_Roll_SR") cmds.setAttr(footSR + ".oldMaxY", 180) cmds.setAttr(footPMA + ".input1D[0]", 180) cmds.setAttr(footPMA + ".operation", 2) #substract cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, footSR + ".valueX", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, footSR + ".valueY", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfAngle, footSR + ".maxX", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfAngle, footSR + ".oldMinY", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfAngle, footSR + ".oldMaxX", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfAngle, footPMA + ".input1D[1]", force=True) cmds.connectAttr(footPMA + ".output1D", footSR + ".maxY", force=True) # plant angle for foot roll: footPlantClp = cmds.createNode("clamp", name=side + self.userGuideName + "_Roll_Plant_Clp") footPlantCnd = cmds.createNode("condition", name=side + self.userGuideName + "_Roll_Plant_Cnd") cmds.setAttr(footPlantCnd + ".operation", 4) #less than cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, footPlantClp + ".inputR", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfPlant, footPlantClp + ".maxR", force=True) cmds.connectAttr(footPlantClp + ".outputR", footPlantCnd + ".firstTerm", force=True) cmds.connectAttr(footPlantClp + ".outputR", footPlantCnd + ".colorIfTrueR", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfPlant, footPlantCnd + ".secondTerm", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfPlant, footPlantCnd + ".colorIfFalseR", force=True) # back to zero footRoll when greather then angle plus plant values: anglePlantPMA = cmds.createNode( "plusMinusAverage", name=side + self.userGuideName + "_AnglePlant_PMA") anglePlantMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_AnglePlant_MD") anglePlantRmV = cmds.createNode( "remapValue", name=side + self.userGuideName + "_AnglePlant_RmV") anglePlantCnd = cmds.createNode( "condition", name=side + self.userGuideName + "_AnglePlant_Cnd") cmds.setAttr(anglePlantMD + ".input2X", -1) cmds.setAttr(anglePlantRmV + ".inputMax", 90) cmds.setAttr(anglePlantRmV + ".value[0].value_Interp", 3) #spline cmds.setAttr(anglePlantRmV + ".value[1].value_Interp", 3) #spline cmds.setAttr(anglePlantCnd + ".operation", 2) #greather than cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfAngle, anglePlantPMA + ".input1D[0]", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll + rfPlant, anglePlantPMA + ".input1D[1]", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, anglePlantCnd + ".firstTerm", force=True) cmds.connectAttr(anglePlantPMA + ".output1D", anglePlantCnd + ".secondTerm", force=True) cmds.connectAttr(anglePlantPMA + ".output1D", anglePlantMD + ".input1X", force=True) cmds.connectAttr(anglePlantPMA + ".output1D", anglePlantRmV + ".inputMin", force=True) cmds.connectAttr(anglePlantMD + ".outputX", anglePlantRmV + ".outputMax", force=True) cmds.connectAttr(self.footCtrl + "." + footRFAttr + rfRoll, anglePlantRmV + ".inputValue", force=True) cmds.connectAttr(anglePlantRmV + ".outColorR", anglePlantCnd + ".colorIfTrueR", force=True) cmds.connectAttr(anglePlantCnd + ".outColorR", self.RFEZeroExtra + ".rotateX", force=True) # connect to groups in order to rotate them: cmds.connectAttr(footSR + ".outValueY", self.RFDZero + ".rotateX", force=True) cmds.connectAttr(footSR + ".outValueX", self.RFEZero + ".rotateX", force=True) if s == 0: #left cmds.connectAttr(footPlantCnd + ".outColorR", self.footCtrlZeroList[1] + ".rotateX", force=True) else: #fix right side mirror footPlantInvMD = cmds.createNode( "multiplyDivide", name=side + self.userGuideName + "_Plant_Inv_MD") cmds.setAttr(footPlantInvMD + ".input2X", -1) cmds.connectAttr(footPlantCnd + ".outColorR", footPlantInvMD + ".input1X", force=True) cmds.connectAttr(footPlantInvMD + ".outputX", self.footCtrlZeroList[1] + ".rotateX", force=True) # organizing keyable attributes: self.ctrls.setLockHide([self.middleFootCtrl, self.footCtrl], ['v'], l=False) # show or hide reverseFoot controls: cmds.addAttr(self.footCtrl, longName=showCtrlsAttr, attributeType='long', min=0, max=1, defaultValue=1) cmds.setAttr(self.footCtrl + "." + showCtrlsAttr, keyable=False, channelBox=True) showHideCtrlList = [ self.RFACtrl, self.RFBCtrl, self.RFCCtrl, self.RFDCtrl ] for rfCtrl in showHideCtrlList: rfCtrlShape = cmds.listRelatives(rfCtrl, children=True, type='nurbsCurve')[0] cmds.connectAttr(self.footCtrl + "." + showCtrlsAttr, rfCtrlShape + ".visibility", force=True) # create a masterModuleGrp to be checked if this rig exists: self.toCtrlHookGrp = cmds.group( self.footCtrlZeroList[0], name=side + self.userGuideName + "_Control_Grp") self.revFootCtrlGrpFinalList.append(self.toCtrlHookGrp) self.toScalableHookGrp = cmds.createNode( "transform", name=side + self.userGuideName + "_Joint_Grp") mWorldFoot = cmds.getAttr(self.footJnt + ".worldMatrix") cmds.xform(self.toScalableHookGrp, matrix=mWorldFoot, worldSpace=True) cmds.parent(self.footJnt, self.toScalableHookGrp, absolute=True) #Remove the Joint orient to make sure the bone is at the same orientation than it's parent cmds.setAttr(self.footJnt + ".jointOrientX", 0) cmds.setAttr(self.footJnt + ".jointOrientY", 0) cmds.setAttr(self.footJnt + ".jointOrientZ", 0) self.aScalableGrp.append(self.toScalableHookGrp) self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string") cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string") cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string") # add module type counter value cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False) cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count) # create a locator in order to avoid delete static group loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE")[0] cmds.parent(loc, self.toStaticHookGrp, absolute=True) cmds.setAttr(loc + ".visibility", 0) self.ctrls.setLockHide([loc], [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v' ]) # add hook attributes to be read when rigging integrated modules: utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook') utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook') utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook') if hideJoints: cmds.setAttr(self.toScalableHookGrp + ".visibility", 0) # delete duplicated group for side (mirror): cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp) # finalize this rig: self.integratingInfo() cmds.select(clear=True) # delete UI (moduleLayout), GUIDE and moduleInstance namespace: self.deleteModule()