def run(self,*args): name = mc.textFieldGrp(self.name, q=True, tx=True) joint = mc.intSliderGrp(self.joint, q=True, v=True) obj = mc.ls(sl=True, o=True) if name == '': print 'ERROR!!' return for i in obj: mc.select(i) if mc.objectType(i) == 'mesh': mc.hilite(i) curves = mc.polyToCurve(usm=False, f=2, dg=1) else: curves = mc.duplicate(rr=True) if mc.checkBoxGrp(self.reverse, q=True, v1=True): mc.reverseCurve() joints = [] for j in range(joint): mc.select(cl=True) joints.append(mc.joint(n=name)) mc.select(mc.ls(joints, curves, tr=True)) apg.positionAlongCurve() for j in range(joint - 1): mc.parent(joints[j + 1], joints[j]) mc.joint(joints[j], e=True, zso=True, oj='xyz', sao='yup') if j == joint - 2: mc.rename(joints[j + 1], name + '_end') mc.delete(curves) mc.select(cl=True)
def archimedesDouble(loops,spiralDown,gaps,height): ''' Creates a Archimedes spiral that spirals out then in again loops : Number of complete turns the spiral should have spiralDown : Direction of the generated curve growth : Growth factor height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral and b controls distance between successive turnings. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). After half the CVs, I reverse the equation to wind the spiral back in. The direction of the curve can be reversed based on the spiralDown flag. ''' curve=cmds.curve(p=[(0,0,0)],n='curve_01') cvNo=int(loops*8) heightFrac = float(height)/cvNo for i in range(1,(cvNo/2)+1): theta=i*(0.25*math.pi) r=(gaps/(1.8*math.pi))*theta x=r*math.cos(theta) y=r*math.sin(theta) cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)]) for i in reversed(range(0,cvNo/2)): theta=i*(0.25*math.pi) r=(gaps/(1.8*math.pi))*theta x=(r*math.cos(theta)) y=-(r*math.sin(theta)) cmds.curve(curve,a=True,p=[(x,height-i*heightFrac,y)]) if spiralDown==True: cmds.reverseCurve(curve,ch=0,rpo=1)
def hyperbolic(loops,spiralIn,height): ''' Creates a hyperbolic spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a hyperbolic spiral is r=a/theta where a scales the spiral. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve=cmds.curve(p=[(0,0,0)],n='curve_01') cvNo=loops*8 heightFrac = float(height)/cvNo for i in range(1,cvNo+2): theta=i*(0.25*math.pi) r=theta**(-1) x=r*math.cos(theta) y=r*math.sin(theta) cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)]) cmds.delete(curve+'.cv[0]') if spiralIn==False: cmds.reverseCurve(curve,ch=0,rpo=1)
def logarithmic(loops, spiralIn, growth, height): ''' Creates a logarithmic spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve growth : Growth factor height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a logarithmic spiral is r=a*e^(b*theta) where a scales the spiral and b controls how tightly it winds. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve = cmds.curve(p=[(0, 0, 0)], n='curve_01') cvNo = loops * 8 heightFrac = float(height) / cvNo for i in range(1, cvNo + 1): theta = i * (0.25 * math.pi) r = 0.1 * (1 / (1.8 * math.pi)) * math.e**(growth * theta) x = r * math.cos(theta) y = r * math.sin(theta) cmds.curve(curve, a=True, p=[(x, i * heightFrac, y)]) if spiralIn == True: cmds.reverseCurve(curve, ch=0, rpo=1)
def nurbsCurve_reverse(*args): '''{'path':'Surfaces/EditNURBS/nurbsCurve_reverse( )', 'icon':':/reverse.png', 'usage':""" #先选择曲线,再选择一个物体,这个命令根据曲线和物体的远近,对这些曲线进行reverse操作 $fun( )""" } ''' if len(args): curvesNode = args[0] refPos = args[1] else: curvesNode = cmds.ls(sl=True, l=True)[:-1] refPos = cmds.objectCenter(cmds.ls(sl=True, l=True)[-1]) for obj in curvesNode: try: startPos = cmds.pointOnCurve(obj, pr=0, ch=False, p=True) endPos = cmds.pointOnCurve(obj, pr=1, ch=False, p=True) startLen = math.sqrt( math.pow(refPos[0] - startPos[0], 2) + math.pow(refPos[1] - startPos[1], 2) + math.pow(refPos[2] - startPos[2], 2)) endLen = math.sqrt( math.pow(refPos[0] - endPos[0], 2) + math.pow(refPos[1] - endPos[1], 2) + math.pow(refPos[2] - endPos[2], 2)) if startLen > endLen: cmds.reverseCurve(obj, ch=False, rpo=True) print 'Reversed %s' % obj except: print obj, " is not nurbscurve!"
def archimedes(loops, spiralIn, gaps, height): ''' Creates a Archimedes spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve gaps : Distance between successive turnings height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral and b controls distance between successive turnings. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve = cmds.curve(p=[(0, 0, 0)], n='curve_01') cvNo = loops * 8 heightFrac = float(height) / cvNo for i in range(1, cvNo + 1): theta = i * (0.25 * math.pi) r = (gaps / (1.8 * math.pi)) * theta x = r * math.cos(theta) y = r * math.sin(theta) cmds.curve(curve, a=True, p=[(x, i * heightFrac, y)]) if spiralIn == True: cmds.reverseCurve(curve, ch=0, rpo=1)
def archimedes(loops,spiralIn,gaps,height): ''' Creates a Archimedes spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve gaps : Distance between successive turnings height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral and b controls distance between successive turnings. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve=cmds.curve(p=[(0,0,0)],n='curve_01') cvNo=loops*8 heightFrac = float(height)/cvNo for i in range(1,cvNo+1): theta=i*(0.25*math.pi) r=(gaps/(1.8*math.pi))*theta x=r*math.cos(theta) y=r*math.sin(theta) cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)]) if spiralIn==True: cmds.reverseCurve(curve,ch=0,rpo=1)
def logarithmic(loops,spiralIn,growth,height): ''' Creates a logarithmic spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve growth : Growth factor height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a logarithmic spiral is r=a*e^(b*theta) where a scales the spiral and b controls how tightly it winds. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve=cmds.curve(p=[(0,0,0)],n='curve_01') cvNo=loops*8 heightFrac = float(height)/cvNo for i in range(1,cvNo+1): theta=i*(0.25*math.pi) r=0.1*(1/(1.8*math.pi))*math.e**(growth*theta) x=r*math.cos(theta) y=r*math.sin(theta) cmds.curve(curve,a=True,p=[(x,i*heightFrac,y)]) if spiralIn==True: cmds.reverseCurve(curve,ch=0,rpo=1)
def hyperbolic(loops, spiralIn, height): ''' Creates a hyperbolic spiral loops : Number of complete turns the spiral should have spiralIn : Direction of the generated curve height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a hyperbolic spiral is r=a/theta where a scales the spiral. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). The direction of the curve can be reversed based on the spiralInwards flag. ''' curve = cmds.curve(p=[(0, 0, 0)], n='curve_01') cvNo = loops * 8 heightFrac = float(height) / cvNo for i in range(1, cvNo + 2): theta = i * (0.25 * math.pi) r = theta**(-1) x = r * math.cos(theta) y = r * math.sin(theta) cmds.curve(curve, a=True, p=[(x, i * heightFrac, y)]) cmds.delete(curve + '.cv[0]') if spiralIn == False: cmds.reverseCurve(curve, ch=0, rpo=1)
def archimedesDouble(loops, spiralDown, gaps, height): ''' Creates a Archimedes spiral that spirals out then in again loops : Number of complete turns the spiral should have spiralDown : Direction of the generated curve growth : Growth factor height : Vertical height of the spiral The curve is created and the required number of control vertices is calculated along with the fraction of the height each CV needs to be placed. The polar equation of a Archimedes spiral is r=a+b*theta where a rotates the spiral and b controls distance between successive turnings. The polar coordinates are converted to Cartesian form by x=r*math.cos(theta) and y=r*math.sin(theta). After half the CVs, I reverse the equation to wind the spiral back in. The direction of the curve can be reversed based on the spiralDown flag. ''' curve = cmds.curve(p=[(0, 0, 0)], n='curve_01') cvNo = int(loops * 8) heightFrac = float(height) / cvNo for i in range(1, (cvNo / 2) + 1): theta = i * (0.25 * math.pi) r = (gaps / (1.8 * math.pi)) * theta x = r * math.cos(theta) y = r * math.sin(theta) cmds.curve(curve, a=True, p=[(x, i * heightFrac, y)]) for i in reversed(range(0, cvNo / 2)): theta = i * (0.25 * math.pi) r = (gaps / (1.8 * math.pi)) * theta x = (r * math.cos(theta)) y = -(r * math.sin(theta)) cmds.curve(curve, a=True, p=[(x, height - i * heightFrac, y)]) if spiralDown == True: cmds.reverseCurve(curve, ch=0, rpo=1)
def __braid(self): steps, porcent = self.__voltas() increment = porcent eight = self.__makeEight() list = range(int(steps)) offset = self.ui.spin_offset.value() offset_normalize = offset/360.0 self.ui.progress_Create.setRange(0,len(list)) scale_0 = self.ui.spin_radius.value() scale_1 = self.ui.spin_radius_1.value() if (scale_0 >= scale_1): scale_maior = scale_0 scale_menor = scale_1 else: scale_maior = scale_1 scale_menor = scale_0 diference = scale_maior-scale_menor percent = diference/steps scale = scale_maior if (self.ui.btn_reverse.isChecked()): curva = self.ui.ln_path.text() cmds.reverseCurve(curva,ch = False, replaceOriginal = True) for i in list: self.ui.progress_Create.setValue(i) self.__next(porcent,eight,scale) porcent += increment _pos_A = (i*0.0625)%1.0 + offset_normalize _pos_B = (i*0.0625+0.333333)%1.0 + offset_normalize _pos_C = (i*0.0625+0.666666666)%1.0 + offset_normalize self.__pt_position_A.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_A, p=True )) self.__pt_position_B.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_B, p=True )) self.__pt_position_C.append(cmds.pointOnCurve( eight[0],top = True, pr= _pos_C, p=True )) scale -= percent self.ui.progress_Create.reset() #cmds.delete(self.__circle[0]) # return self.__pt_position self.__curve() cmds.delete(eight[0])
def sqCheckCurveDirection(self, thisCurve, *args): posMinX = cmds.xform(thisCurve + ".cv[0]", query=True, worldSpace=True, translation=True)[0] posMaxX = cmds.xform(thisCurve + ".cv[" + str(self.curveLenght - 1) + "]", query=True, worldSpace=True, translation=True)[0] if posMinX > posMaxX: cmds.reverseCurve(thisCurve, constructionHistory=False, replaceOriginal=True)
def reverseCurve(*args): sel = cmds.ls(sl=True, exactType="transform") check = False if sel: for x in sel: check = curveCheck(x) if check: cmds.reverseCurve(x, ch=False, replaceOriginal=True) else: cmds.warning("Must select some curves") return cmds.select(sel, r=True)
def LDRibbonTools_reverseCurve(): sel = cmds.ls(sl=1, o=1) for i in sel: shapeNode = cmds.listRelatives(i, s=1) nodeType = cmds.nodeType(shapeNode) if nodeType == 'nurbsCurve': curveName = i cmds.reverseCurve(curveName, ch=1, rpo=1) else: curveWarpName = cmds.listConnections(i, t='curveWarp') if curveWarpName != None: curveName = cmds.listConnections(curveWarpName, t='curveShape') curveName = curveName[0] cmds.reverseCurve(curveName, rpo=1) cmds.select(sel, r=1)
def createCurve_circleFourArrows(self, name=""): """ Creates a nurbs curve in the shape of a circle with four arrows Args: Returns: """ startCurve1 = cmds.curve(d=3, p=[(-0.448148, 0, -0.137417), (-0.425577, 0, -0.210319), (-0.345762, 0, -0.345408), (-0.210765, 0, -0.425313), (-0.138183, 0, -0.447335)], k=[0, 0, 0, 1, 2, 2, 2]) startCurve2 = cmds.curve(d=1, p=[(-0.138183, 0, -0.447335), (-0.138183, 0, -0.552734), (-0.276367, 0, -0.552734), (0, 0, -0.829101), (0.276367, 0, -0.552734), (0.138183, 0, -0.552734), (0.138183, 0, -0.447335)], k=[0, 1, 2, 3, 4, 5, 6]) curve1 = cmds.attachCurve(startCurve1, startCurve2, replaceOriginal=0, kmk=1, ch=0) cmds.delete(startCurve1, startCurve2) curve2 = cmds.duplicate(curve1) cmds.rotate(0, 90, 0, curve1) curve3 = cmds.duplicate(curve1) cmds.rotate(0, 180, 0, curve3) curve4 = cmds.duplicate(curve1) cmds.rotate(0, 270, 0, curve4) attachCurve1 = cmds.attachCurve(curve1, curve2, replaceOriginal=0, kmk=1, ch=0) attachCurve2 = cmds.attachCurve(curve3, curve4, replaceOriginal=0, kmk=1, ch=0) cmds.delete(curve1, curve2, curve3, curve4) attachCurve2 = cmds.reverseCurve(attachCurve2[0], ch=0, rpo=1) newCurve = cmds.attachCurve(attachCurve1[0], attachCurve2[0], replaceOriginal=0, kmk=1, ch=0) cmds.delete(attachCurve1[0], attachCurve2[0]) cmds.makeIdentity(newCurve, apply=1, t=1, r=1, s=1, n=0) ret = cmds.rename(newCurve, name) return ret
def snap_root_CV_to_mesh(*args): ''' Snap root CV of curve to closest point on mesh for selected mesh and curves which are currently selected. ''' initialSelection = cmds.ls(sl=True) scalpMesh = cmds.ls(sl=True, dag=True, type='mesh')[0] curveSet = cmds.listRelatives(cmds.ls(sl=True, dag=True, type='nurbsCurve'), parent=True) CPOM_A = cmds.createNode('closestPointOnMesh') CPOM_B = cmds.createNode('closestPointOnMesh') cmds.connectAttr(scalpMesh+'.outMesh', CPOM_A+'.inMesh') cmds.connectAttr(scalpMesh+'.outMesh', CPOM_B+'.inMesh') for CRV in curveSet: #CRV = curveSet[0] curveLen = int(cmds.arclen(CRV)/3+4) rebuildCRV = cmds.rebuildCurve(CRV, d=3, spans=curveLen) #print CRV CRVroot = cmds.pointPosition(CRV+'.cv[0]', world=True) CRVvec = cmds.pointPosition(CRV+'.cv[2]', world=True) abc = ['X', 'Y', 'Z'] for x in abc: cmds.setAttr(CPOM_A+'.inPosition'+x, CRVroot[abc.index(x)]) cmds.setAttr(CPOM_B+'.inPosition'+x, CRVvec[abc.index(x)]) CPOM_rootPOS = cmds.getAttr(CPOM_A+'.position')[0] CPOM_vecPOS = cmds.getAttr(CPOM_B+'.position')[0] #print CRV, CRVroot, CPOM_POS cmds.reverseCurve(CRV) CRVcvs = cmds.getAttr(CRV+'.spans') #print CRV, curveLen, CRVcvs, rebuildCRV cmds.delete(CRV, constructionHistory=True) CRVshape = cmds.listRelatives(CRV, children=True) cmds.curve(CRVshape, a=True, ws=True, p=[CPOM_vecPOS, CPOM_rootPOS])#[(0,0,0) for x in range(CRVcvs/5)]) cmds.reverseCurve(CRV) cmds.rebuildCurve(CRV, degree=3, spans=CRVcvs+2) cmds.smoothCurve(CRV+'.cv[*]', smoothness=10) #break cmds.select(initialSelection)
def reverseCrv(*args): sel = cmds.ls(sl=True)[0] shp = cmds.listRelatives(sel, shapes=True) if cmds.objectType(shp) != "nurbsCurve": cmds.warning("not a nurbs curve to reverse") else: revCrv = cmds.reverseCurve(sel, rpo=True, ch=False)[0] cmds.select(revCrv) print("reversed curve: %s!" % revCrv)
def create_turntable(self): """Automatically creates 360 degree turntable with lights relative to object size""" # Creates object selection which selects current object in panel view objectSelection = cmds.ls(sl=True) bBox = cmds.exactWorldBoundingBox(objectSelection) objectDistance = cmds.shadingNode('distanceBetween', asUtility=True) locator1 = cmds.spaceLocator() locatorShape1 = cmds.listRelatives(locator1[0], shapes=True) locator2 = cmds.spaceLocator() locatorShape2 = cmds.listRelatives(locator2[0], shapes=True) #Creates ground cylinder for selected object. objectGround = cmds.polyCylinder(axis=[0, 1, 0], height=bBox[4] / 10.0, radius=bBox[3] * 2.5, subdivisionsX=30, subdivisionsZ=1, n='turntableGround') cmds.setAttr(objectGround[0] + '.translateY', bBox[1] - (bBox[4] / 10.0) / 2) cmds.parent(locator2[0], objectSelection[0]) cmds.setAttr(locator1[0] + '.translateX', 0) cmds.setAttr(locator1[0] + '.translateY', 0) cmds.setAttr(locator1[0] + '.translateZ', 0) cmds.setAttr(locator2[0] + '.translateX', 0) cmds.setAttr(locator2[0] + '.translateY', 0) cmds.setAttr(locator2[0] + '.translateZ', 0) cmds.connectAttr(locatorShape1[0] + '.worldPosition', objectDistance + '.point1') cmds.connectAttr(locatorShape2[0] + '.worldPosition', objectDistance + '.point2') #Creates nurb circle for the turntable and adjusts position based on object selected. cameraCircle = cmds.circle(radius = bBox[3] * 9, sections = 50) cmds.setAttr(cameraCircle[0] + '.rotateX', 90) cmds.reverseCurve(cameraCircle[0]) cmds.setAttr(cameraCircle[0] + '.translateY', bBox[1] - (bBox[4] / 10.0) / 2) cmds.select(cameraCircle, r=True) cmds.move(0, 5, 0) #Creates turntable camera and groups the camera, circle, and ground. cmds.camera(n='turntableCamera') cmds.group('nurbsCircle1', 'turntableCamera1', 'turntableGround', n='cameraSetup') # Creates a path animation based on the objects 'turntableCamera1' and 'cameraCircle' cmds.pathAnimation('turntableCamera1', cameraCircle[0], fractionMode=True, follow=True, followAxis='x', upAxis='y', worldUpType='vector', worldUpVector=[0, 1, 0], inverseUp=False, inverseFront=False, bank=False, startTimeU=1, endTimeU=120) cmds.delete('locator1', 'locator2')
def polytoCurve(self): blist = cmds.ls(sl=1) for i in blist: vnum = cmds.polyEvaluate(i, v=1) for v in range(vnum): enum = cmds.ls(cmds.polyListComponentConversion(i + '.vtx[' + str(v) + ']', fv=1, ff=1, fuv=1, fvf=1, te=1), fl=1) if len(enum) == 4: break arclen = [] for e in enum: elist = cmds.polySelectSp(e, q=1, loop=1) earclen = 0.0 for el in elist: earclen += cmds.arclen(el) arclen.append(earclen) cmds.polySelectSp(enum[arclen.index(max(arclen))], loop=1) cname = cmds.rename(cmds.polyToCurve( ch=0, form=2, degree=3), i + '_Cur') if cmds.xform(cname + '.cv[0]', q=1, ws=1, t=1)[1] < cmds.xform(cname + '.cv[' + str(cmds.getAttr(cname + ".controlPoints", size=1)) + ']', q=1, ws=1, t=1)[1]: cmds.reverseCurve(cname, ch=0, rpo=1)
def dpSetCurveDirection(self, curveName, *args): """ Check and set the curve direction. Reverse curve direction if the first CV position is greather than last CV position by current axis. """ cmds.setAttr(curveName + "." + ZIPPER_ATTR, 0) cmds.select(curveName + ".cv[*]") curveLength = len(cmds.ls(selection=True, flatten=True)) cmds.select(clear=True) minPos = cmds.xform(curveName + ".cv[0]", query=True, worldSpace=True, translation=True)[self.curveAxis] maxPos = cmds.xform(curveName + ".cv[" + str(curveLength - 1) + "]", query=True, worldSpace=True, translation=True)[self.curveAxis] if minPos > maxPos: cmds.reverseCurve(curveName, constructionHistory=True, replaceOriginal=True) cmds.rename( cmds.listConnections(curveName + ".create")[0], utils.extractSuffix(curveName) + "_" + self.curveDirection + "_RevC")
def execute(self): sx = self.sx sy = self.sy sdv = self.sdv sdu = self.sdu tap = self.tap degs = self.degs subCurve = self.subCurve clean = self.clean do_uvs = self.do_uvs rbc = self.rbc cTol = self.cTol cSubd = self.cSubd if cmds.checkBox(self.aUACCB, q=True, v=True): useAltShape = True else: useAltShape = False multSel = cmds.ls(sl=True,fl=True, ap=True) if cmds.objectType(multSel[0]) == 'mesh': thisIsAMesh = True else: thisIsAMesh = False # Select curve type to extrude along - convert and store for x in multSel: print x if thisIsAMesh != True: cmds.select(x) else: cmds.select(multSel) objSel = cmds.ls(sl=True,fl=True, ap=True) if self.ko == 1: dupObj = cmds.duplicate(objSel) objSel = dupObj if len(objSel) > 1: print objSel if degs == 0: curveDg = cmds.promptDialog(t='Enter Degrees:', m='Enter Degrees - ie. 1 for linear, 3 for curved') objSel = cmds.polyToCurve(f=2, dg=int(cmds.promptDialog(q=True, tx=True))) else: objSel = cmds.polyToCurve(f=2, dg=int(degs), n='%s_curve' %objSel[0].split('.')[0]) else: objType = cmds.listRelatives(objSel[0], f=True) if cmds.objectType(objType[0]) != 'nurbsCurve' and cmds.objectType(objType[0]) != 'bezierCurve': cmds.error('Select the nurbs curve first, then the object to align') if cmds.objectType(objType[0]) == 'bezierCurve': mm.eval("bezierCurveToNurbs;") # Create a nurbs curve for the extrusion if useAltShape: nurbsCir = self.objToUse else: nurbsCir = cmds.circle(n='extrudeCircle', d=3, r=1, nr=(0,0,1), sw=360, ch=True, s=8) objCV = cmds.ls('%s.ep[*]' %objSel[0], fl=True) noOfCV = len(objCV) firstCV = 0 lastCV = noOfCV - 1 cvNumberToUse=firstCV # Rebuild the curve to help with uniformity if self.rev == 1: cmds.reverseCurve(objSel[0], ch=0, rpo=1) if rbc == 1: try: cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=4,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol) cmds.rebuildCurve(objSel[0], ch=0,rpo=1,rt=0,end=1,kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol) except: cmds.warning('Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off') if do_uvs == 1: objShape = cmds.listRelatives(objSel[0], c=True, type='shape') mInfo = cmds.shadingNode('curveInfo', n='cMeasure', asUtility=True) cmds.connectAttr('%s.local' %objShape[0], '%s.inputCurve' %mInfo) curveLength = cmds.getAttr('%s.arcLength' %mInfo) cmds.delete(mInfo) self.uvRatio = float((((sx * sy)*2.0) * math.pi) / curveLength) print "uvRatio: " + str(self.uvRatio) # Create a tangent contraint to position nurbs circle to the first cv cvPos = cmds.xform('%s.ep[%d]' %(objSel[0],cvNumberToUse), query=True, ws=True, t=True) cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0],cvPos[1],cvPos[2])) fastCon = cmds.tangentConstraint(objSel[0], nurbsCir[0], aim=(0,0,1)) cmds.delete(fastCon[0]) # Extrude along curve and set attributes pipeExt = cmds.extrude(nurbsCir[0], objSel[0], n='%s_pipe' %objSel[0], ch=True, rn=subCurve, po=1, et=2, ucp=1, fpt=1,upn=1, rotation=0, scale=1,rsp=1) pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate') if subCurve != 0: pipeSubCurve = cmds.listConnections(pipeExt[1], type='subCurve') cmds.setAttr('%s.format' %pipeTes[0],2) cmds.setAttr('%s.polygonType' %pipeTes[0],1) cmds.setAttr('%s.uType' %pipeTes[0],2) cmds.setAttr('%s.vType' %pipeTes[0],2) cmds.setAttr('%s.vNumber' %pipeTes[0],sdv) cmds.setAttr('%s.uNumber' %pipeTes[0],sdu) # Add attributes if clean == 0: cmds.addAttr(pipeExt[0], ln='________', k=True) cmds.setAttr('%s.________' %pipeExt[0], l=True) cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx) cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy) cmds.connectAttr('%s.Ext_ScaleX' %pipeExt[0], '%s.scaleX' %nurbsCir[0]) cmds.connectAttr('%s.Ext_ScaleY' %pipeExt[0], '%s.scaleY' %nurbsCir[0]) cmds.addAttr(pipeExt[0], ln='Ext_DivisionV', at='short', k=True, dv=sdv) cmds.connectAttr('%s.Ext_DivisionV' %pipeExt[0], '%s.vNumber' %pipeTes[0]) cmds.addAttr(pipeExt[0], ln='Ext_DivisionU', at='short', k=True, dv=sdu) cmds.connectAttr('%s.Ext_DivisionU' %pipeExt[0], '%s.uNumber' %pipeTes[0]) if subCurve != 0: cmds.addAttr(pipeExt[0], ln='Ext_Length', k=True, dv=1, max=1, min=0) cmds.connectAttr('%s.Ext_Length' %pipeExt[0], '%s.maxValue' %pipeSubCurve[1]) cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0) cmds.connectAttr('%s.Ext_Taper' %pipeExt[0], '%s.scale' %pipeExt[1]) cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1) cmds.connectAttr('%s.Ext_Twist' %pipeExt[0], '%s.rotation' %pipeExt[1]) cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1) cmds.connectAttr('%s.Ext_ComponentPivot' %pipeExt[0], '%s.useComponentPivot' %pipeExt[1]) curveGrpNode = cmds.createNode('transform', n='pipeCurves') cmds.parent(nurbsCir, curveGrpNode) cmds.parent(objSel, curveGrpNode) cmds.setAttr('%s.inheritsTransform' %curveGrpNode, 0) cmds.setAttr('%s.visibility' %curveGrpNode, 1) cmds.parent(curveGrpNode, pipeExt[0]) cmds.select(pipeExt[0]) if do_uvs == 1: cmds.polyLayoutUV(ps=0.2) cmds.polyEditUV(sv=1, su=self.uvRatio) cmds.polyEditUV(sv=0.95, su=0.95) cmds.select(pipeExt[0]) CentreUVs() if clean == 1: cmds.delete(ch=True) cmds.delete(curveGrpNode) cmds.select(pipeExt[0]) if thisIsAMesh == True: print 'hello' break
def cutCurve( curve, mesh, loopCheck = False ): fnMesh = getMFnMesh( mesh ) fnCurve = getMFnCurve( curve ) meshIntersector = om.MMeshIntersector() meshIntersector.create( fnMesh.object() ) meshMtx = fnMesh.dagPath().inclusiveMatrix() curveMtx = fnCurve.dagPath().inclusiveMatrix() toMeshLocalMtx = curveMtx*meshMtx.inverse() numSpans = fnCurve.numSpans() maxParam = fnCurve.findParamFromLength( fnCurve.length() ) paramRate = maxParam / ( numSpans-1 ) point = om.MPoint() pointOnMesh = om.MPointOnMesh() closestParam = 0.0 for i in range( numSpans ): fnCurve.getPointAtParam( paramRate*i, point ) toMeshPoint = point*toMeshLocalMtx meshIntersector.getClosestPoint( toMeshPoint, pointOnMesh ) closePoint = om.MPoint( pointOnMesh.getPoint() ) normal = om.MVector( pointOnMesh.getNormal() ) closePivVector = om.MVector( toMeshPoint )-om.MVector( closePoint ) if closePivVector*normal < 0: closestParam = paramRate*i else: if i == 0: if loopCheck: return None cmds.reverseCurve( curve, ch=0, rpo=1 ) cutCurve( curve, mesh, True ) i = 0 addParam = 1 while i < 100: fnCurve.getPointAtParam( closestParam, point ) toMeshPoint = point*toMeshLocalMtx meshIntersector.getClosestPoint( toMeshPoint, pointOnMesh ) closePoint = om.MPoint( pointOnMesh.getPoint() ) cuDist = closePoint.distanceTo( toMeshPoint ) if cuDist < 0.0001: break normal = om.MVector( pointOnMesh.getNormal() ) closePivVector = om.MVector( toMeshPoint ) - om.MVector( closePoint ) if closePivVector*normal > 0: addParam = math.fabs( addParam ) * -0.5 else: addParam = math.fabs( addParam ) * 0.5 closestParam += addParam i+=1 fnCurve.getPointAtParam( closestParam, point ) first, second = cmds.detachCurve( "%s.u[%f]" %( curve, closestParam ), ch=0, cos=True, rpo=0 ) curveObj = cmds.listRelatives( curve, p=1 )[0] cmds.delete( first, curveObj ) second = cmds.rename( second, curveObj ) cmds.select( second ) cmds.DeleteHistory()
def __func__(self): """ """ _str_funcName = self._str_funcCombined curve = self.d_kws['curve'] points = self.d_kws['points'] mi_crv = cgmMeta.validateObjArg(self.d_kws['curve'],cgmMeta.cgmObject,mayaType='nurbsCurve',noneValid=False) int_points = cgmValid.valueArg(self.d_kws['points'],minValue=1,calledFrom = _str_funcName) f_insetSplitFactor = cgmValid.valueArg(self.d_kws['insetSplitFactor'],calledFrom = _str_funcName) f_startSplitFactor = cgmValid.valueArg(self.d_kws['startSplitFactor'],calledFrom = _str_funcName) f_kwMinU = cgmValid.valueArg(self.d_kws['minU'], noneValid=True, calledFrom = _str_funcName) f_kwMaxU = cgmValid.valueArg(self.d_kws['maxU'], noneValid=True, calledFrom = _str_funcName) f_points = float(int_points) int_spans = int(cgmValid.valueArg(self.d_kws['points'],minValue=5,autoClamp=True,calledFrom = _str_funcName)) b_rebuild = cgmValid.boolArg(self.d_kws['rebuildForSplit'],calledFrom = _str_funcName) b_markPoints = cgmValid.boolArg(self.d_kws['markPoints'],calledFrom = _str_funcName) b_reverseCurve = cgmValid.boolArg(self.d_kws['reverseCurve'],calledFrom = _str_funcName) try:#>>> Rebuild curve if b_rebuild: useCurve = mc.rebuildCurve (curve, ch=0, rpo=0, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001)[0] else: useCurve = mc.duplicate(curve)[0] if b_reverseCurve: useCurve = mc.reverseCurve(useCurve,rpo = True)[0] except Exception,error:raise StandardError,"Rebuild fail | %s"%error try:#>>> Divide stuff #========================== l_spanUPositions = [] str_bufferU = mc.ls("%s.u[*]"%useCurve)[0] log.debug("%s >> u list : %s"%(_str_funcName,str_bufferU)) f_maxU = float(str_bufferU.split(':')[-1].split(']')[0]) l_uValues = [0] if points == 1: l_uValues = [f_maxU/2] elif f_startSplitFactor is not False: if points < 5: raise StandardError,"Need at least 5 points for startSplitFactor. Points : %s"%(points) log.debug("%s >> f_startSplitFactor : %s"%(_str_funcName,f_startSplitFactor)) #Figure out our u's f_base = f_startSplitFactor * f_maxU l_uValues.append( f_base ) f_len = f_maxU - (f_base *2) int_toMake = f_points-4 f_factor = f_len/(int_toMake+1) log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU)) log.debug("%s >> f_len : %s"%(_str_funcName,f_len)) log.debug("%s >> int_toMake : %s"%(_str_funcName,int_toMake)) log.debug("%s >> f_base : %s"%(_str_funcName,f_base)) log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor)) for i in range(1,int_points-3): l_uValues.append(((i*f_factor + f_base))) l_uValues.append(f_maxU - f_base) l_uValues.append(f_maxU) log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues)) elif f_insetSplitFactor is not False: log.debug("%s >> f_insetSplitFactor : %s"%(_str_funcName,f_insetSplitFactor)) #Figure out our u's f_base = f_insetSplitFactor * f_maxU f_len = f_maxU - (f_base *2) f_factor = f_len/(f_points-1) log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU)) log.debug("%s >> f_len : %s"%(_str_funcName,f_len)) log.debug("%s >> f_base : %s"%(_str_funcName,f_base)) log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor)) for i in range(1,int_points-1): l_uValues.append((i*f_factor)) l_uValues.append(f_maxU) log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues)) elif f_kwMinU is not False or f_kwMaxU is not False: log.debug("%s >> Sub mode. "%(_str_funcName)) if f_kwMinU is not False: if f_kwMinU > f_maxU: raise StandardError, "kw minU value(%s) cannot be greater than maxU(%s)"%(f_kwMinU,f_maxU) f_useMinU = f_kwMinU else:f_useMinU = 0.0 if f_kwMaxU is not False: if f_kwMaxU > f_maxU: raise StandardError, "kw maxU value(%s) cannot be greater than maxU(%s)"%(f_kwMaxU,f_maxU) f_useMaxU = f_kwMaxU else:f_useMaxU = f_maxU if int_points == 1: l_uValues = [(f_useMaxU - f_useMinU)/2] elif int_points == 2: l_uValues = [f_useMaxU,f_useMinU] else: l_uValues = [f_useMinU] f_factor = (f_useMaxU - f_useMinU)/(f_points-1) log.debug("%s >> f_maxU : %s"%(_str_funcName,f_useMaxU)) log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor)) for i in range(1,int_points-1): l_uValues.append((i*f_factor) + f_useMinU) l_uValues.append(f_useMaxU) else: #Figure out our u's log.debug("%s >> Regular mode. Points = %s "%(_str_funcName,int_points)) if int_points == 3: l_uValues.append(f_maxU/2) l_uValues.append(f_maxU) else: f_factor = f_maxU/(f_points-1) log.debug("%s >> f_maxU : %s"%(_str_funcName,f_maxU)) log.debug("%s >> f_factor : %s"%(_str_funcName,f_factor)) for i in range(1,int_points-1): l_uValues.append(i*f_factor) l_uValues.append(f_maxU) log.debug("%s >> l_uValues : %s"%(_str_funcName,l_uValues)) except Exception,error:raise StandardError,"Divide fail | %s"%error for u in l_uValues: try:l_spanUPositions.append(mc.pointPosition("%s.u[%f]"%(useCurve,u))) except StandardError,error:raise StandardError,"Failed on pointPositioning: %s"%u log.debug("%s >> l_spanUPositions | len: %s | list: %s"%(_str_funcName,len(l_spanUPositions),l_spanUPositions)) try: if b_markPoints: ml_built = [] for i,pos in enumerate(l_spanUPositions): buffer = mc.spaceLocator(n = "%s_u_%f"%(useCurve,(l_uValues[i])))[0] ml_built.append( cgmMeta.cgmObject(buffer)) log.debug("%s >> created : %s | at: %s"%(_str_funcName,ml_built[-1].p_nameShort,pos)) mc.xform(ml_built[-1].mNode, t = (pos[0],pos[1],pos[2]), ws=True) if len(ml_built)>1: try:f_distance = distance.returnAverageDistanceBetweenObjects([o.mNode for o in ml_built]) * .5 except StandardError,error:raise StandardError,"Average distance fail. Objects: %s| error: %s"%([o.mNode for o in ml_built],error) try: for o in ml_built: o.scale = [f_distance,f_distance,f_distance] except StandardError,error:raise StandardError,"Scale fail : %s"%error except StandardError,error:log.error("Mark points fail. error : %s"%(error)) mc.delete(useCurve)#Delete our use curve return l_spanUPositions
def _create(self): mi_base = self.mi_baseCurve mi_target = self.mi_targetCurve self.l_baseCvPos = [] self.d_base = self.getCurveMirrorData(mi_base) if not mi_target:#if no target, mirror self if not self.d_base['b_oneSided']: if self.d_base['b_even']: log.info("%s Even mirror"%self._str_reportStart) l_cvPos = self.d_base['l_cvPos'] l_cvs = self.d_base['l_cvs'] int_split = int(len(l_cvPos)/2) log.info(int_split) l_splitDriven = l_cvs[int_split:] l_splitDriver = l_cvs[:int_split] l_splitDriverPos = l_cvPos[:int_split] l_splitDriverPos.reverse() log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven)) log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver)) for i,cv in enumerate(l_splitDriven): pos = l_splitDriverPos[i] mc.move(-pos[0],pos[1],pos[2], cv, ws=True) return True else: log.info("%s nonEven mirror"%self._str_reportStart) l_cvPos = self.d_base['l_cvPos'] l_cvs = self.d_base['l_cvs'] int_split = int(len(l_cvPos)/2) l_cvPos.pop(int_split) l_cvs.pop(int_split) l_splitDriven = l_cvs[int_split:] l_splitDriver = l_cvs[:int_split] l_splitDriverPos = l_cvPos[:int_split] l_splitDriverPos.reverse() log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven)) log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver)) for i,cv in enumerate(l_splitDriven): pos = l_splitDriverPos[i] mc.move(-pos[0],pos[1],pos[2], cv, ws=True) return True else:#it's one sided log.info("%s Build other side. New crv"%self._str_reportStart) l_epPos = self.d_base['l_epPos'] l_otherSide = copy.copy(l_epPos) l_otherSide.reverse() for i,pos in enumerate(l_otherSide): l_otherSide[i] = [-pos[0],pos[1],pos[2]] #l_newCurvePos = l_epPos + l_otherSide l_newCurvePos = l_otherSide l_newCurvePos = lists.returnListNoDuplicates(l_newCurvePos) self.mi_created = cgmMeta.cgmObject( mc.curve(d=2,p=l_newCurvePos,os = True) ) self.mi_created.rename( mi_base.p_nameBase + '_mirrored') # if self.d_base['b_startInThreshold'] or self.d_base['b_endInThreshold']: #In this case we need to combine and rebuild the curve try: str_attachedCurves = mc.attachCurve([self.mi_created.mNode,self.mi_baseCurve.mNode], blendBias = self.d_kws['blendBias']) except Exception,error:raise StandardError,"Attach curve | %s"%error #mc.delete(self.mi_created.mNode)#delete the old one #self.mi_created = cgmMeta.cgmObject(str_attachedCurves[0]) #int_spans = (len(l_epPos)*1.5) int_spans = len(l_epPos)+1 try: mc.rebuildCurve (self.mi_created.mNode, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001) except Exception,error:raise StandardError,"Rebuild curve | %s"%error try: mc.reverseCurve (self.mi_created.mNode, rpo=1) except Exception,error:raise StandardError,"Reverse curve | %s"%error self.mi_created.rename( mi_base.p_nameBase + '_mirrored') return self.mi_created.p_nameShort #See if we need to make new curve to have stuff to mirror else:#if we have a target self.d_target = self.getCurveMirrorData(mi_target) l_cvsBase = self.d_base['l_cvs'] l_cvsTarget = self.d_target['l_cvs'] if len(l_cvsBase) != len(l_cvsTarget): raise NotImplementedError,"Haven't added ability to do curves of differing cv lengths yet" for i,pos in enumerate(self.d_base['l_cvPos']): mc.move(-pos[0],pos[1],pos[2], l_cvsTarget[i], ws=True) return True
def createConveyerBeltSet( meshName, firstEdgeIndex, secondEdgeIndex ): firstEdges = cmds.polySelectSp( meshName+'.e[%d]' % firstEdgeIndex, loop=1 ) secondEdges = cmds.polySelectSp( meshName+'.e[%d]' % secondEdgeIndex, loop=1 ) cmds.select( firstEdges ) firstCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_First' )[0] cmds.select( secondEdges ) secondCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_Second' )[0] firstCurveShape = sgModelDag.getShape( firstCurve ) secondCurveShape = sgModelDag.getShape( secondCurve ) firstSpans = cmds.getAttr( firstCurveShape +'.spans' ) secondSpans = cmds.getAttr( secondCurveShape+'.spans' ) firstTangent = sgModelCurve.getTangentAtParam( firstCurveShape, 0.0 ) firstParamPoint = sgModelCurve.getPointAtParam( firstCurveShape, 0.0 ) secondParam = sgModelCurve.getParamAtPoint( secondCurveShape, firstParamPoint ) secondTangent = sgModelCurve.getTangentAtParam( secondCurveShape, secondParam ) if firstTangent * secondTangent < 0: cmds.reverseCurve( secondCurve, ch = 1, rpo = 1 ) firstPointers = sgRigCurve.createRoofPointers( firstCurve, firstSpans ) secondPointers = sgRigCurve.createRoofPointers( secondCurve, secondSpans ) fPos = cmds.xform( firstPointers[0], q=1, ws=1, t=1 ) minDistPointer = secondPointers[0] minDist = 1000000000.0 for secondPointer in secondPointers: sPos = cmds.xform( secondPointer, q=1, ws=1, t=1 ) dist = (fPos[0]-sPos[0])**2+(fPos[1]-sPos[1])**2+(fPos[2]-sPos[2])**2 if dist < minDist: minDistPointer = secondPointer minDist = dist offset = int( minDistPointer.split( '_' )[-1] ) crvs = [] for i in range( len( firstPointers ) ): firstPointer = firstPointers[i] secondPointer = '_'.join( secondPointers[i].split( '_' )[:-1] ) + '_%d' %( (i + offset)%firstSpans ) crv = sgRigCurve.createCurveOnTargetPoints( [firstPointer, secondPointer] ) crv = cmds.rename( crv, meshName+'_line_%d' % i ) crvs.append( crv ) cmds.select( crvs ) loftSurf = cmds.loft( n=meshName+'_loft' )[0] resultObject = cmds.nurbsToPoly( loftSurf ,mnd=1 ,ch=1,f=3,pt=0,pc=200,chr=0.9,ft=0.01,mel=0.001, d=0.1, ut=1, un=3, vt=1, vn=3, uch=0, ucr=0, cht=0.2, es=0,ntr=0,mrt=0, uss=1, n=meshName+'_conveyorBelt' ) crvGrp = cmds.group( crvs, n=meshName+'_lines' ) conveyorRig = cmds.group( firstCurve, secondCurve, crvGrp, loftSurf, resultObject, meshName, n=meshName+'_conveyorRig' ) import sgRigAttribute sgRigAttribute.addAttr( conveyorRig, ln='offset', k=1 ) cmds.connectAttr( conveyorRig+'.offset', firstCurve+'.roofValue' ) cmds.connectAttr( conveyorRig+'.offset', secondCurve+'.roofValue' ) cmds.setAttr( conveyorRig+'.v', 0 )
def execute(self): sx = self.sx sy = self.sy sdv = self.sdv sdu = self.sdu tap = self.tap degs = self.degs subCurve = self.subCurve clean = self.clean do_uvs = self.do_uvs rbc = self.rbc cTol = self.cTol cSubd = self.cSubd if cmds.checkBox(self.aUACCB, q=True, v=True): useAltShape = True else: useAltShape = False multSel = cmds.ls(sl=True, fl=True, ap=True) if cmds.objectType(multSel[0]) == 'mesh': thisIsAMesh = True else: thisIsAMesh = False # Select curve type to extrude along - convert and store for x in multSel: print x if thisIsAMesh != True: cmds.select(x) else: cmds.select(multSel) objSel = cmds.ls(sl=True, fl=True, ap=True) if self.ko == 1: dupObj = cmds.duplicate(objSel) objSel = dupObj if len(objSel) > 1: print objSel if degs == 0: curveDg = cmds.promptDialog( t='Enter Degrees:', m='Enter Degrees - ie. 1 for linear, 3 for curved') objSel = cmds.polyToCurve(f=2, dg=int( cmds.promptDialog(q=True, tx=True))) else: objSel = cmds.polyToCurve(f=2, dg=int(degs), n='%s_curve' % objSel[0].split('.')[0]) else: objType = cmds.listRelatives(objSel[0], f=True) if cmds.objectType( objType[0]) != 'nurbsCurve' and cmds.objectType( objType[0]) != 'bezierCurve': cmds.error( 'Select the nurbs curve first, then the object to align' ) if cmds.objectType(objType[0]) == 'bezierCurve': mm.eval("bezierCurveToNurbs;") # Create a nurbs curve for the extrusion if useAltShape: nurbsCir = self.objToUse else: nurbsCir = cmds.circle(n='extrudeCircle', d=3, r=1, nr=(0, 0, 1), sw=360, ch=True, s=8) objCV = cmds.ls('%s.ep[*]' % objSel[0], fl=True) noOfCV = len(objCV) firstCV = 0 lastCV = noOfCV - 1 cvNumberToUse = firstCV # Rebuild the curve to help with uniformity if self.rev == 1: cmds.reverseCurve(objSel[0], ch=0, rpo=1) if rbc == 1: try: cmds.rebuildCurve(objSel[0], ch=0, rpo=1, rt=4, end=1, kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol) cmds.rebuildCurve(objSel[0], ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=cSubd, d=3, tol=cTol) except: cmds.warning( 'Tolerance for rebuild likely to low, try a higher value or turn Rebuild Curve off' ) if do_uvs == 1: objShape = cmds.listRelatives(objSel[0], c=True, type='shape') mInfo = cmds.shadingNode('curveInfo', n='cMeasure', asUtility=True) cmds.connectAttr('%s.local' % objShape[0], '%s.inputCurve' % mInfo) curveLength = cmds.getAttr('%s.arcLength' % mInfo) cmds.delete(mInfo) self.uvRatio = float( (((sx * sy) * 2.0) * math.pi) / curveLength) print "uvRatio: " + str(self.uvRatio) # Create a tangent contraint to position nurbs circle to the first cv cvPos = cmds.xform('%s.ep[%d]' % (objSel[0], cvNumberToUse), query=True, ws=True, t=True) cmds.xform(nurbsCir[0], ws=True, t=(cvPos[0], cvPos[1], cvPos[2])) fastCon = cmds.tangentConstraint(objSel[0], nurbsCir[0], aim=(0, 0, 1)) cmds.delete(fastCon[0]) # Extrude along curve and set attributes pipeExt = cmds.extrude(nurbsCir[0], objSel[0], n='%s_pipe' % objSel[0], ch=True, rn=subCurve, po=1, et=2, ucp=1, fpt=1, upn=1, rotation=0, scale=1, rsp=1) pipeTes = cmds.listConnections(pipeExt[1], type='nurbsTessellate') if subCurve != 0: pipeSubCurve = cmds.listConnections(pipeExt[1], type='subCurve') cmds.setAttr('%s.format' % pipeTes[0], 2) cmds.setAttr('%s.polygonType' % pipeTes[0], 1) cmds.setAttr('%s.uType' % pipeTes[0], 2) cmds.setAttr('%s.vType' % pipeTes[0], 2) cmds.setAttr('%s.vNumber' % pipeTes[0], sdv) cmds.setAttr('%s.uNumber' % pipeTes[0], sdu) # Add attributes if clean == 0: cmds.addAttr(pipeExt[0], ln='________', k=True) cmds.setAttr('%s.________' % pipeExt[0], l=True) cmds.addAttr(pipeExt[0], ln='Ext_ScaleX', k=True, dv=sx) cmds.addAttr(pipeExt[0], ln='Ext_ScaleY', k=True, dv=sy) cmds.connectAttr('%s.Ext_ScaleX' % pipeExt[0], '%s.scaleX' % nurbsCir[0]) cmds.connectAttr('%s.Ext_ScaleY' % pipeExt[0], '%s.scaleY' % nurbsCir[0]) cmds.addAttr(pipeExt[0], ln='Ext_DivisionV', at='short', k=True, dv=sdv) cmds.connectAttr('%s.Ext_DivisionV' % pipeExt[0], '%s.vNumber' % pipeTes[0]) cmds.addAttr(pipeExt[0], ln='Ext_DivisionU', at='short', k=True, dv=sdu) cmds.connectAttr('%s.Ext_DivisionU' % pipeExt[0], '%s.uNumber' % pipeTes[0]) if subCurve != 0: cmds.addAttr(pipeExt[0], ln='Ext_Length', k=True, dv=1, max=1, min=0) cmds.connectAttr('%s.Ext_Length' % pipeExt[0], '%s.maxValue' % pipeSubCurve[1]) cmds.addAttr(pipeExt[0], ln='Ext_Taper', k=True, dv=tap, min=0) cmds.connectAttr('%s.Ext_Taper' % pipeExt[0], '%s.scale' % pipeExt[1]) cmds.addAttr(pipeExt[0], ln='Ext_Twist', k=True, dv=1) cmds.connectAttr('%s.Ext_Twist' % pipeExt[0], '%s.rotation' % pipeExt[1]) cmds.addAttr(pipeExt[0], ln='Ext_ComponentPivot', k=True, dv=1) cmds.connectAttr('%s.Ext_ComponentPivot' % pipeExt[0], '%s.useComponentPivot' % pipeExt[1]) curveGrpNode = cmds.createNode('transform', n='pipeCurves') cmds.parent(nurbsCir, curveGrpNode) cmds.parent(objSel, curveGrpNode) cmds.setAttr('%s.inheritsTransform' % curveGrpNode, 0) cmds.setAttr('%s.visibility' % curveGrpNode, 1) cmds.parent(curveGrpNode, pipeExt[0]) cmds.select(pipeExt[0]) if do_uvs == 1: cmds.polyLayoutUV(ps=0.2) cmds.polyEditUV(sv=1, su=self.uvRatio) cmds.polyEditUV(sv=0.95, su=0.95) cmds.select(pipeExt[0]) CentreUVs() if clean == 1: cmds.delete(ch=True) cmds.delete(curveGrpNode) cmds.select(pipeExt[0]) if thisIsAMesh == True: print 'hello' break
def sysFromEdgeLoop(edge, surface, name=""): # Extract curve from edge cmds.select(edge) anchor_curve = cmds.polyToCurve(name=name + '_Anchor_Crv', form=2, degree=1, conformToSmoothMeshPreview=0)[0] # Check curve direction and reverse reverse_crv = xDirection_positive(anchor_curve) if reverse_crv is False: cmds.reverseCurve(anchor_curve, ch=0, rpo=1) cmds.delete(anchor_curve, ch=1) # Create locators on each anchor curve CV locator_list = locatorOnCVs(anchor_curve, scale=0.2) # Connect locators to CVs loc_pci_node_list = connectLocatorToCrv(locator_list, anchor_curve) # Duplicate -> Rebuild to low res driver_crv = cmds.duplicate(anchor_curve, name=name + '_Driver_Crv')[0] cmds.rebuildCurve(driver_crv, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=6, d=1, tol=0.01) cmds.rebuildCurve(driver_crv, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=1, kep=1, kt=1, s=4, d=3, tol=0.01) cmds.delete(driver_crv, ch=1) # Wire high res to low res curve driver_wire_node = cmds.wire(anchor_curve, w=driver_crv, gw=False, en=1.000000, ce=0.000000, li=0.000000) # Create joints on each low res CV cv_postion = getCVAngle(driver_crv) driver_jnt_list = [] ctrl_dict = {} ctrl_list = [] remoteCtrl_loc_dict = {} remoteCtrl_loc_list = [] for n, position in enumerate(cv_postion): cmds.select(cl=1) driver_jnt = cmds.joint(rad=0.3, n="{}_{:02d}_Ctrl_Jnt".format(name, n)) driver_jnt_list.append(driver_jnt) cmds.xform(driver_jnt, t=position[0], ro=[0, position[1][1], 0]) # Create controls for each joint ctrl_data = tpu.build_ctrl(ctrl_type="cube", name="{}_{:02d}".format(name, n), scale=0.3, spaced=1) ctrl_dict.update({ctrl_data['control']: ctrl_data['group']}) ctrl_list.append(ctrl_data['control']) cmds.xform(ctrl_data['group'], t=position[0], ro=[0, position[1][1], 0]) # Create remote ctrl locator remoteCtrl_loc = cmds.spaceLocator( n="{}_{:02d}_RemoteCtrl_Loc".format(name, n))[0] for i in "X,Y,Z".split(","): cmds.setAttr("{}.localScale{}".format(remoteCtrl_loc, i), 0.3) remoteCtrl_loc_grp = cmds.group(remoteCtrl_loc, n=remoteCtrl_loc + "_Grp") remoteCtrl_loc_dict.update({remoteCtrl_loc: remoteCtrl_loc_grp}) remoteCtrl_loc_list.append(remoteCtrl_loc) cmds.xform(remoteCtrl_loc_grp, t=position[0], ro=[0, position[1][1], 0]) # Connect control/joint transforms cmds.parentConstraint(remoteCtrl_loc, driver_jnt, mo=1) for attr in ".t,.rotate,.s".split(','): cmds.connectAttr(ctrl_data['control'] + attr, remoteCtrl_loc + attr, f=1) # Bind low res curve to joints skinCluster_node = cmds.skinCluster(driver_jnt_list, driver_crv) # Create system on surface surface_sys_data = follicleOnClosestPoint(surface, locator_list, name) follicle_dict = surface_sys_data[0] # Create joints for each follicle follicle_jnt_list = jointsOnSelection(follicle_dict.keys(), constraint=True, rad=0.2) # Group and organize system on Outliner crv_grp = cmds.group(anchor_curve, driver_crv, driver_crv + "BaseWire", n="{}_Crv_Grp".format(name)) # Locator Groups remoteCtrl_loc_grp = cmds.group(remoteCtrl_loc_dict.values(), n="{}_RemoteCtrl_Loc_Grp".format(name)) aim_loc_grp = cmds.group(locator_list, n="{}_Aim_Loc_Grp".format(name)) locator_grp = cmds.group(remoteCtrl_loc_grp, aim_loc_grp, n="{}_Loc_Grp".format(name)) # Joint groups bind_joint_grp = cmds.group(follicle_jnt_list, n="{}_Bind_Jnt_Grp".format(name)) ctrl_joint_grp = cmds.group(driver_jnt_list, n="{}_Ctrl_Jnt_Grp".format(name)) joint_grp = cmds.group(bind_joint_grp, ctrl_joint_grp, n="{}_Jnt_Grp".format(name)) # Controls group ctrl_grp = cmds.group(ctrl_dict.values(), n="{}_Ctrl_Grp".format(name)) # Follicle group follicle_grp = cmds.group(follicle_dict.keys(), n="{}_Flc_Grp".format(name)) main_sys_grp = cmds.group(crv_grp, locator_grp, ctrl_grp, follicle_grp, joint_grp, n="{}_Sys_Grp".format(name)) sys_data = { "main_sys_grp": main_sys_grp, "loc_pci_node_list": loc_pci_node_list, "driver_wire_node": driver_wire_node, "skinCluster_node": skinCluster_node, "surface_closestPoint_node_list": surface_sys_data[1], "surface_setRange_node_list": surface_sys_data[2], "ctrl_list": ctrl_list, "ctrl_dict": ctrl_dict, "remoteCtrl_dict": remoteCtrl_loc_dict, "remoteCtrl_list": remoteCtrl_loc_list } return sys_data
def sqCheckCurveDirection(self, thisCurve, *args): posMinX = cmds.xform(thisCurve+".cv[0]", query=True, worldSpace=True, translation=True)[0] posMaxX = cmds.xform(thisCurve+".cv["+str(self.curveLenght-1)+"]", query=True, worldSpace=True, translation=True)[0] if posMinX > posMaxX: cmds.reverseCurve(thisCurve, constructionHistory=False, replaceOriginal=True)
def reverseCurve(*args, **kwargs): res = cmds.reverseCurve(*args, **kwargs) if not kwargs.get('query', kwargs.get('q', False)): res = _factories.maybeConvert(res, _general.PyNode) return res
def surfRigger(objectNull,anchor,worldScale,mirror,mode,jointsPerChain,deformChains,ctrlChains): """ Get variables""" nullBase = names.stripSuffixObj (objectNull) templateNull = (nullBase + '_templateNull') moverNull = (nullBase + '_mover') templateNullMessageData = [] templateNullMessageData = attributes.returnMessageAttrs (templateNull) templateObjects = [] coreNamesList = [] spineJointNumber = int(mc.getAttr (objectNull+'.rollJoints')) #spineChainList = search.returnChildrenJoints (spineChain) spineChainList = [] spineChainList.append (anchor) jointChains = [] for set in templateNullMessageData: templateObjects.append (set[1]) coreNamesList.append (set[0]) #>>>>>>>>>>>>>>>>>>>>>Store skin joint data """ check for master skin info group """ if mc.objExists ('master_skinJntList_grp'): masterSkinJointList = ('master_skinJntList_grp') else: masterSkinJointList = mc.group (n= ('master_skinJntList_grp'), w=True, empty=True) mc.parent(masterSkinJointList,'rigStuff_grp') """ check for segment skin info group """ if mc.objExists (nullBase+'_skinJntList_grp'): skinJointListGrp = (nullBase+'_skinJntList_grp') else: skinJointListGrp = mc.group (n= (nullBase+'_skinJntList_grp'), w=True, empty=True) attributes.storeObjNameToMessage (skinJointListGrp,masterSkinJointList) mc.parent (skinJointListGrp,masterSkinJointList) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ Rebuild curve - with actual curve in it!""" mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[11]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) """ Reverse the curve """ mc.reverseCurve ((templateObjects[3]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[7]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[11]),ch=False,rpo=True) """ loft our surface to figure out joint positions, then delete it""" controlSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(ctrlChains-mode),ch=1,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) mc.select (cl=True) jointChains = joints.createJointChainsFromLoftSurface (nullBase,controlSurface[0],2,False) frontChain = jointChains[0] backChain = jointChains[-1] """ Chain - orienting, sizing """ for chain in jointChains: joints.orientJointChain (chain, 'xyz', 'zup') joints.setGoodJointRadius(chain,.5) #IF we have mode 0, gotta make a main ctrl if mode == 0: midChain = [] if (len(jointChains)) > 3: midChain = jointChains[int(len(jointChains)/2)] else: midChain = jointChains[1] jointChains.remove(midChain) if ctrlChains > 2: masterCtrlBuffer = mc.duplicate (midChain[0],parentOnly=True) else: masterCtrlBuffer = midChain[0] mc.delete (midChain[1]) masterCtrl = mc.rename (masterCtrlBuffer,(nullBase+'_master_anim')) position.movePointSnap(masterCtrl,moverNull) """ temp parenting the master control for mirroring purposes """ spineHookJoint = distance.returnClosestObject (masterCtrl, spineChainList) mc.parent (masterCtrl,spineHookJoint) mc.delete (controlSurface[0]) #>>>>>>>>>>>>Parent time """ Get closest joint """ if mode == 0: for chain in jointChains: mc.parent (chain[0],masterCtrl) else: for chain in jointChains: tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) mc.parent (chain[0],tailHookJoint) #>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ctrl Joints to Ctrls cnt = 0 for chain in jointChains: ctrlSize = (distance.returnAverageDistanceBetweenObjects (chain)/2) for jnt in chain[0:-1]: rigging.makeObjCtrl (jnt,ctrlSize) """ adds our Anim tag """ chainBuffer = [] chainBuffer = names.addSuffixList ('anim', chain) jointChains[cnt]= chainBuffer cnt +=1 #>>>>>>>>>>>>>>>>>>>Mirroring while getting chain info """ If mirroring ....""" if mirror == True: # if we have a main control leftSkinChains = [] rightSkinChains = [] masterCtrls = [] if mode == 0: leftChain = [] rightChain = [] finHeirarchy = [] finHeirarchy.append (masterCtrl) children = search.returnChildrenJoints (masterCtrl) finHeirarchy += children leftChain = names.addPrefixList ('left',finHeirarchy) masterCtrl = leftChain [0] rightChainBuffer = mc.mirrorJoint (masterCtrl,mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right']) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer leftSkinChains.append(leftChain) rightSkinChains.append(rightChain) masterCtrls.append(leftChain[0]) masterCtrls.append(rightChain[0]) else: for chain in jointChains: leftChain =[] leftChain = names.addPrefixList ('left',chain) rightChainBuffer = (mc.mirrorJoint (leftChain[0],mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right'])) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer rightSkinChains.append (rightChainJointBuffer) leftSkinChains.append (leftChain) """ complile our chains to lists of skin joints """ leftSkinJointList=[] rightSkinJointList=[] for chain in leftSkinChains: for jnt in chain: leftSkinJointList.append (jnt) for chain in rightSkinChains: for jnt in chain: rightSkinJointList.append (jnt) """if we're not mirroring, let's return our skin joints for the deformation surface""" else: skinJointList = [] skinChains = [] for chain in jointChains: skinChains.append (chain) for jnt in chain: skinJointList.append (jnt) #>>>>>>>>>>>>>>>>>>>>>>>>>>Time to make the deformation surface stuff """ Rebuild curve - with actual curve in it!""" #mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) #mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) """ loft our surface to figure out joint positions, then delete it""" deformSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(deformChains-1),ch=0,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) if mirror == True: deformSurfaceNameBuffer = deformSurface[0] """we have a surface to mirror...""" surfaceMirrorBuffer = mc.duplicate (deformSurface[0]) mc.setAttr ((surfaceMirrorBuffer[0]+'.sx'),-1) leftBuffer = mc.rename (deformSurface[0],('left_'+deformSurfaceNameBuffer)) rightBuffer = mc.rename (surfaceMirrorBuffer[0],('right_'+deformSurfaceNameBuffer)) deformSurface[0]=leftBuffer deformSurface.append(rightBuffer) leftDeformJointChains = joints.createJointChainsFromLoftSurface (('left_'+nullBase),deformSurface[0],2,False) rightDeformJointChains = joints.createJointChainsFromLoftSurface (('right_'+nullBase),deformSurface[1],2,False) """ Connecting to surface """ for chain in leftDeformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) for chain in rightDeformJointChains: attachSurfaceMirrorReturn = joints.attachJointChainToSurface (chain,deformSurface[1],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection s we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') for item in attachSurfaceMirrorReturn[0]: mc.parent(item,'rigStuff_grp') """ hook up world scale """ mc.connectAttr (worldScale,attachSurfaceReturn[1]) mc.connectAttr (worldScale,attachSurfaceMirrorReturn[1]) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Skin in the control joints """ Time to set skin our surface to our control joints """ mc.skinCluster (leftSkinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) mc.skinCluster (rightSkinJointList,deformSurface[1],tsb=True, n=(deformSurface[1]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) #>>>>>If we,re not mirrored, let's make our deform setup else: deformJointChains = [] deformJointChains = joints.createJointChainsFromLoftSurface (nullBase,deformSurface[0],2,False) """ Connecting to surface """ for chain in deformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ hook up world scale """ partScaleBuffer = attachSurfaceReturn[1] mc.connectAttr (worldScale, partScaleBuffer) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') """ Time to set skin our surface to our control joints """ mc.skinCluster (skinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) """ Setting up the joint starts""" if mode == 0: if mirror == True: for ctrl in masterCtrls: rigging.makeObjCtrl (ctrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (ctrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) else: rigging.makeObjCtrl (masterCtrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (masterCtrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) #else we need to connect the individual chains to the spine else: if mirror == True: for chain in leftSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) for chain in rightSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) else: for chain in skinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint)
def createFKSys(ctrl_amount, curve, name, color1=(0, 1, 0), color2=(0.5, 0.5, 0.5)): # Declaring all function variables in dictionary fk_data = { 'jnt_ctrl_list': [], 'jnt_ctrl_grp_list': [], 'fk_ctrl_list': [], 'fk_ctrl_grp_list': [], 'jnt_remoteCtrl_list': [], 'jnt_remoteCtrl_grp_list': [], 'fk_remoteCtrl_list': [], 'fk_remoteCtrl_grp_list': [], 'fk_ctrl_grp': "", 'fk_remoteCtrl_grp': "", 'joint_list': [], 'joint_group': "", 'curve': "", 'wire': "", 'base_wire': "" } # Duplicate main curve fk_data['curve'] = cmds.duplicate( curve, name="{}_MainCtrl_FKDriver_Crv".format(name))[0] # Rebuild curve - Same as control amount - 1 linear - Convert curve to 3 cubic cmds.rebuildCurve(fk_data['curve'], rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=1, s=ctrl_amount, d=1, tol=0.01) cmds.rebuildCurve(fk_data['curve'], rpo=1, rt=0, end=1, kr=0, kcp=1, kep=1, kt=1, s=4, d=3, tol=0.01) cmds.reverseCurve(fk_data['curve'], ch=0, rpo=1) # Freeze curve transforms, Delete history, center pivot cmds.makeIdentity(fk_data['curve'], apply=True, t=1, r=1, s=1, n=0) cmds.xform(fk_data['curve'], cp=1) # Do joints on curve CV's fk_data['joint_list'] = jointsOnCVs(fk_data['curve'], name) # Do controls on joints jnt_ctrl_data = placeOnEach_joint(fk_data['joint_list'], type="cube", scale=1, color=color1, name=name, sufix="_Jnt_Ctrl") fk_data['jnt_ctrl_list'] = jnt_ctrl_data[0] fk_data['jnt_ctrl_grp_list'] = jnt_ctrl_data[1] # jnt_ctrls remote - Parent ON jnt_remoteCtrl_data = placeOnEach_joint(fk_data['joint_list'], type="cube", scale=1, color=color1, constraint=1, name=name, sufix="_Jnt_Remote_Ctrl") fk_data['jnt_remoteCtrl_list'] = jnt_remoteCtrl_data[0] fk_data['jnt_remoteCtrl_grp_list'] = jnt_remoteCtrl_data[1] # Do FK controls on controls fk_ctrl_data = placeOnEachSel(fk_data['jnt_ctrl_list'], type="circle", scale=2, color=color2, spaced=1, name=name, sufix="_FK_Ctrl") fk_data['fk_ctrl_list'] = fk_ctrl_data[0] fk_data['fk_ctrl_grp_list'] = fk_ctrl_data[1] # FK controls remote fk_remoteCtrl_data = placeOnEachSel(fk_data['jnt_ctrl_list'], type="circle", scale=2, spaced=1, name=name, sufix="_FK_Remote_Ctrl") fk_data['fk_remoteCtrl_list'] = fk_remoteCtrl_data[0] fk_data['fk_remoteCtrl_grp_list'] = fk_remoteCtrl_data[1] fk_data['fk_ctrl_grp'] = fk_data['fk_ctrl_grp_list'][-1] fk_data['fk_remoteCtrl_grp'] = fk_data['fk_remoteCtrl_grp_list'][-1] # Parent joint ctrls to FK controls for grp, ctrl in zip(fk_data['jnt_ctrl_grp_list'], fk_data['fk_ctrl_list']): cmds.parent(grp, ctrl) for grp, ctrl in zip(fk_data['jnt_remoteCtrl_grp_list'], fk_data['fk_remoteCtrl_list']): cmds.parent(grp, ctrl) # Parent FK controls in order parent_FkOrder(fk_data['fk_ctrl_list'], fk_data['fk_ctrl_grp_list']) parent_FkOrder(fk_data['fk_remoteCtrl_list'], fk_data['fk_remoteCtrl_grp_list']) # Connect controls and remote controls for ctrl, remote in zip(fk_data['jnt_ctrl_list'], fk_data['jnt_remoteCtrl_list']): connectTransform(ctrl, remote, t=1, ro=1, s=1) for ctrl, remote in zip(fk_data['fk_ctrl_list'], fk_data['fk_remoteCtrl_list']): connectTransform(ctrl, remote, t=1, ro=1, s=1) # Wire highRes curve to lowRes fk_data['wire'] = cmds.wire(curve, gw=False, en=1.0, ce=0.0, li=0.0, dds=(0, 100), w=fk_data['curve'], n="{}_FkSys_Wire_Def".format(name))[0] fk_data['base_wire'] = fk_data['curve'] + "BaseWire" # Bind joints to curve cmds.skinCluster(fk_data['joint_list'], fk_data['curve']) fk_data['joint_group'] = cmds.group(fk_data['joint_list'], n="{}_FK_Jnt_Grp".format(name)) return fk_data
def cutCurve(curve, mesh, loopCheck=False): fnMesh = getMFnMesh(mesh) fnCurve = getMFnCurve(curve) meshIntersector = om.MMeshIntersector() meshIntersector.create(fnMesh.object()) meshMtx = fnMesh.dagPath().inclusiveMatrix() curveMtx = fnCurve.dagPath().inclusiveMatrix() toMeshLocalMtx = curveMtx * meshMtx.inverse() numSpans = fnCurve.numSpans() maxParam = fnCurve.findParamFromLength(fnCurve.length()) paramRate = maxParam / (numSpans - 1) point = om.MPoint() pointOnMesh = om.MPointOnMesh() closestParam = 0.0 for i in range(numSpans): fnCurve.getPointAtParam(paramRate * i, point) toMeshPoint = point * toMeshLocalMtx meshIntersector.getClosestPoint(toMeshPoint, pointOnMesh) closePoint = om.MPoint(pointOnMesh.getPoint()) normal = om.MVector(pointOnMesh.getNormal()) closePivVector = om.MVector(toMeshPoint) - om.MVector(closePoint) if closePivVector * normal < 0: closestParam = paramRate * i else: if i == 0: if loopCheck: return None cmds.reverseCurve(curve, ch=0, rpo=1) cutCurve(curve, mesh, True) i = 0 addParam = 1 while i < 100: fnCurve.getPointAtParam(closestParam, point) toMeshPoint = point * toMeshLocalMtx meshIntersector.getClosestPoint(toMeshPoint, pointOnMesh) closePoint = om.MPoint(pointOnMesh.getPoint()) cuDist = closePoint.distanceTo(toMeshPoint) if cuDist < 0.0001: break normal = om.MVector(pointOnMesh.getNormal()) closePivVector = om.MVector(toMeshPoint) - om.MVector(closePoint) if closePivVector * normal > 0: addParam = math.fabs(addParam) * -0.5 else: addParam = math.fabs(addParam) * 0.5 closestParam += addParam i += 1 fnCurve.getPointAtParam(closestParam, point) first, second = cmds.detachCurve("%s.u[%f]" % (curve, closestParam), ch=0, cos=True, rpo=0) curveObj = cmds.listRelatives(curve, p=1)[0] cmds.delete(first, curveObj) second = cmds.rename(second, curveObj) cmds.select(second) cmds.DeleteHistory()
def createSetup(): jointNumstr = rig.textField('jointNumText', q=True, tx=True) jointName = rig.textField('jointNameText', q=True, tx=True) jointName = jointName + '_' orient = rig.radioButtonGrp('jointOrientGrp', q=True, sl=True) currntCurve = rig.textField('Shap', q=True, tx=True) jointNum = int(jointNumstr) disdenceList = [] jointList = [] aim = '' xyz = '' if (orient == 1): aim = 'xyz' xyz = 'tx' elif (orient == 2): aim = 'yzx' xyz = 'ty' elif (orient == 3): aim = 'zxy' xyz = 'tz' if (rig.checkBox('rebCurve', q=True, v=True)): vtxNum = len(rig.ls(currntCurve + '.cv[*]', fl=True)) rig.rebuildCurve(currntCurve, ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=vtxNum, d=3, tol=0.001) if (rig.checkBox('revCurve', q=True, v=True)): rig.reverseCurve(currntCurve, ch=True, rpo=True) rig.select(cl=True) ListShape = om.MSelectionList() ListShape.add(currntCurve) curveNode = om.MDagPath() ListShape.getDagPath(0, curveNode) CurveMFn = om.MFnNurbsCurve(curveNode) curveLength = CurveMFn.length() averageNum = curveLength / (jointNum - 1) pnt = om.MPoint() deLength = 0 for x in range(jointNum): curParam = CurveMFn.findParamFromLength(deLength) CurveMFn.getPointAtParam(curParam, pnt, om.MSpace.kWorld) jointN = rig.createNode('pointOnCurveInfo', n=jointName + 'jointPos' + str(x), ss=True) rig.connectAttr(currntCurve + '.worldSpace', jointN + '.inputCurve') # # rig.setAttr(jointN+'.turnOnPercentage',1) rig.setAttr(jointN + '.parameter', curParam) currentJoint = rig.joint(p=(rig.getAttr(jointN + '.positionX'), rig.getAttr(jointN + '.positionY'), rig.getAttr(jointN + '.positionZ')), n='Joint_' + jointName + str(x)) jointList.append(currentJoint) deLength += averageNum if (x): disName = rig.createNode('distanceBetween', n=jointName + 'Dis' + str(x), ss=True) rig.connectAttr(jointName + 'jointPos' + str(x - 1) + '.position', disName + '.point1') rig.connectAttr(jointN + '.position', disName + '.point2') disdenceList.append(disName) rig.joint(jointList[0], e=True, oj=aim, secondaryAxisOrient='yup', ch=True, zso=True) rig.joint(jointList[-1], e=True, oj='none', secondaryAxisOrient='yup', ch=True, zso=True) groupName = rig.group(empty=True, n=jointName + 'Group') scaleNode = rig.scaleConstraint(jointList[0], groupName, mo=True) for n, i in enumerate(disdenceList): multi = rig.createNode('multiplyDivide', n='MD_' + i) rig.setAttr(multi + '.operation', 2) rig.connectAttr(i + '.distance', multi + '.input1.input1X') rig.connectAttr(groupName + '.scale', multi + '.input2') rig.connectAttr(multi + '.output.outputX', jointList[n + 1] + '.' + xyz) rig.ikHandle(n=jointName + 'IKSpine', sol='ikSplineSolver', ccv=False, sj=jointList[0], ee=jointList[-1], c=currntCurve)
""" Build middle hair section """ #Start with template curve middleStrand = cmds.curve(p=[(-1,0,-0.125),(-0.9375,-0.0875,-0.1875),(-0.84375,-0.06375,-0.26),(-0.7578125,-0.0053125,-0.275),(-0.6875,0.0425,-0.26),(-0.625,0.06375,-0.234375),(-0.5625,0.0425,-0.1875),(-0.5,0,-0.125),(-0.4375,-0.0875221,-0.0625),(-0.375,-0.06375,-0.015625),(-0.3125,-0.0425,0),(-0.2421875,0.0053125,0),(-0.15625,0.06375,0),(-0.0625,0.0425,-0.0625),(0,0,-0.125),(0.0625,-0.08752214296547417,-0.1875),(0.15625,-0.06375,-0.26),(0.2421875,-0.0053125,-0.275),(0.3125,0.0425,-0.26),(0.375,0.06375,-0.234375),(0.4375,0.0425,-0.1875),(0.5,0,-0.125),(0.5625,-0.0875221,-0.0625),(0.625,-0.06375,-0.015625),(0.6875,-0.0425,0),(0.7578125,0.0053125,0),(0.84375,0.06375,0),(0.9375,0.0425,-0.0625),(1,0,-0.125)], k=[0,0,0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6,6,6,6.5,7,7.5,8,8.5,9,9.5,10,10.5,11,11.5,12,12,12], name='middleStrand') msTemplate = cmds.duplicate('middleStrand', name='msTemplate') #Add length to top appendMSTop = cmds.duplicate('msTemplate', name='middleStrand2') cmds.move(-2,0,0,'middleStrand2', relative=True) cmds.attachCurve('middleStrand', 'middleStrand2') cmds.delete('middleStrand2') if append == 0: cmds.reverseCurve('middleStrand', rpo=True) #Append length if necessary cutbottom = 24 - 1.71725261027258 #Curve point at which to detach curve for i in xrange(0, append): toAppend = cmds.duplicate('msTemplate', name='middleStrand2') cmds.move(2*(i+1),0,0,'middleStrand2', relative=True) cmds.attachCurve('middleStrand','middleStrand2') cmds.delete('middleStrand2') cutbottom = (24+12*(i+1)) - 1.71725261027258 - 6*(i+1) #Cut top of curve cmds.detachCurve('middleStrand.u[10.2827459692]', k=(0,1), replaceOriginal=True) cmds.delete('middleStrand') cmds.rename('middleStranddetachedCurve2', 'middleStrand')
def createConveyerBeltSet(meshName, firstEdgeIndex, secondEdgeIndex): firstEdges = cmds.polySelectSp(meshName + '.e[%d]' % firstEdgeIndex, loop=1) secondEdges = cmds.polySelectSp(meshName + '.e[%d]' % secondEdgeIndex, loop=1) cmds.select(firstEdges) firstCurve = cmds.polyToCurve(form=2, degree=3, n=meshName + '_loopCurve_First')[0] cmds.select(secondEdges) secondCurve = cmds.polyToCurve(form=2, degree=3, n=meshName + '_loopCurve_Second')[0] firstCurveShape = sgModelDag.getShape(firstCurve) secondCurveShape = sgModelDag.getShape(secondCurve) firstSpans = cmds.getAttr(firstCurveShape + '.spans') secondSpans = cmds.getAttr(secondCurveShape + '.spans') firstTangent = sgModelCurve.getTangentAtParam(firstCurveShape, 0.0) firstParamPoint = sgModelCurve.getPointAtParam(firstCurveShape, 0.0) secondParam = sgModelCurve.getParamAtPoint(secondCurveShape, firstParamPoint) secondTangent = sgModelCurve.getTangentAtParam(secondCurveShape, secondParam) if firstTangent * secondTangent < 0: cmds.reverseCurve(secondCurve, ch=1, rpo=1) firstPointers = sgRigCurve.createRoofPointers(firstCurve, firstSpans) secondPointers = sgRigCurve.createRoofPointers(secondCurve, secondSpans) fPos = cmds.xform(firstPointers[0], q=1, ws=1, t=1) minDistPointer = secondPointers[0] minDist = 1000000000.0 for secondPointer in secondPointers: sPos = cmds.xform(secondPointer, q=1, ws=1, t=1) dist = (fPos[0] - sPos[0])**2 + (fPos[1] - sPos[1])**2 + (fPos[2] - sPos[2])**2 if dist < minDist: minDistPointer = secondPointer minDist = dist offset = int(minDistPointer.split('_')[-1]) crvs = [] for i in range(len(firstPointers)): firstPointer = firstPointers[i] secondPointer = '_'.join(secondPointers[i].split('_')[:-1]) + '_%d' % ( (i + offset) % firstSpans) crv = sgRigCurve.createCurveOnTargetPoints( [firstPointer, secondPointer]) crv = cmds.rename(crv, meshName + '_line_%d' % i) crvs.append(crv) cmds.select(crvs) loftSurf = cmds.loft(n=meshName + '_loft')[0] resultObject = cmds.nurbsToPoly(loftSurf, mnd=1, ch=1, f=3, pt=0, pc=200, chr=0.9, ft=0.01, mel=0.001, d=0.1, ut=1, un=3, vt=1, vn=3, uch=0, ucr=0, cht=0.2, es=0, ntr=0, mrt=0, uss=1, n=meshName + '_conveyorBelt') crvGrp = cmds.group(crvs, n=meshName + '_lines') conveyorRig = cmds.group(firstCurve, secondCurve, crvGrp, loftSurf, resultObject, meshName, n=meshName + '_conveyorRig') import sgRigAttribute sgRigAttribute.addAttr(conveyorRig, ln='offset', k=1) cmds.connectAttr(conveyorRig + '.offset', firstCurve + '.roofValue') cmds.connectAttr(conveyorRig + '.offset', secondCurve + '.roofValue') cmds.setAttr(conveyorRig + '.v', 0)