def create_waveSystem(self): horizAmp = self.autoJnt.addAttr('horizontalAmplitude', attributeType='float', min=-5, max=5, defaultValue=0, keyable=True) horizWaveLength = self.autoJnt.addAttr('horizontalWaveLength', attributeType='float', min=-.01, max=1, defaultValue=1, keyable=True) vertAmp = self.autoJnt.addAttr('verticalAmplitude', attributeType='float', min=-5, max=5, defaultValue=0, keyable=True) vertWaveLength = self.autoJnt.addAttr('verticalWaveLength', attributeType='float', min=-.01, max=1, defaultValue=1, keyable=True) #horizontal deformer horizontalWave, horizontalWaveHandle = pm.nonLinear( self.ribbonSystem.nurbsPatch, type='wave') horizontalWave.renameNode(name=self.TipName, base="%sWaveDeformerHorizontal_1") horizontalWaveHandle.renameNode(name=self.TipName, base="%sWaveDeformerHorizontal_1") #vertical deformer verticalWave, verticalWaveHandle = pm.nonLinear( self.ribbonSystem.nurbsPatch, type='wave') verticalWave.renameNode(name=self.TipName, base="%sWaveDeformerHorizontal") verticalWaveHandle.renameNode(name=self.TipName, base="%sWaveDeformerHorizontal") pm.delete( pm.orientConstraint(self.fkJnts[0], horizontalWaveHandle, maintainOffset=False)) pm.delete( pm.orientConstraint(self.fkJnts[0], verticalWaveHandle, maintainOffset=False)) horizontalWaveHandle.rx.set(horizontalWaveHandle.rx.get() + 90) horizAmp.connect(horizontalWave.amp) horizWaveLength.connect(horizontalWave.wav) vertAmp.connect(verticalWave.amp) vertWaveLength.connect(verticalWave.wav)
def createBendDeformerOnCurve(curveTransforms, upDir=(1,0,0), aimDir=(0,1,0)): '''Creates bend deformers on every curve and aims them at the end Args: curveTransforms ([pm.nt.Transform]): list of transforms with nurbsCurve shapes upDir (float, float, float): up direction for aim to orient the bend deformer Returns: ([pm.nt.nonLinear]): list of bend deformers Usage: createBendDeformerOnCurve(pm.ls(sl=True)) ''' bends=[] for curveTransform in curveTransforms: bendName = curveTransform.name().replace('CRV','BEND') bend = pm.nonLinear(curveTransform, type='bend', frontOfChain=True, curvature=0.0, lowBound=0, highBound=1) bend[0].rename(bendName.replace('BEND','BENDHDL')) bend[1].rename(bendName) startPosition = curveTransform.getShape().cv[0].getPosition(space='world') endPosition = curveTransform.getShape().cv[-1].getPosition(space='world') loc = pm.spaceLocator() pm.move(loc, endPosition, a=True) pm.move(bend[1], startPosition, a=True) aimConst = pm.aimConstraint( loc, bend[1], upVector=upDir, aimVector=aimDir ) pm.delete([loc, aimConst]) bends.append(bend) return bends
def makeLantern(): #clear workspace cmds.select(all=True) cmds.delete() #get values from sliders ridges = cmds.intSliderGrp(ridgesSlider, q=True, value=True) deform = cmds.intSliderGrp(deformSlider, q=True, value=True) bend = cmds.intSliderGrp(bendSlider, q=True, value=True) bendNum = bend/100.0+1.0 flatten = float(cmds.intSliderGrp(flattenSlider, q=True, value=True)) lantern = pm.polySphere(n='lantern', sx=10, r=1, sy=ridges) rings = pm.polySelect( lantern, er=1) pm.select(lantern, cl=True) toggle = True for i in rings: if toggle: pm.polySelect( lantern, el=i) pm.scale(pm.selected(), [bendNum,bendNum,bendNum], xz=True) toggle = not toggle pm.select(lantern) pm.displaySmoothness(divisionsU=3, divisionsV=3, pointsWire=16, pointsShaded=4, polygonObject=3) wave = pm.nonLinear(type='wave', amplitude=0.03) pm.setAttr(wave[0]+'.wavelength', deform/100+0.1) pm.rotate(wave, 0, 0, '45deg') pm.select(all=True) pm.scale(lantern, [1,1-(flatten/100),1], xyz=True) pm.delete(ch=True)
def importDeformers(fileName): deformerDict = json.loads(open(fileName).read()) fileDir = '\\'.join(fileName.split('\\')[:-1]) for key in deformerDict.keys(): geo = deformerDict[key]['geo'] pm.select(geo) dfm = pm.nonLinear(name=key, type=deformerDict[key]['nlType']) pm.xform(dfm[1], ws=1, m=deformerDict[key]['mtx']) parent = deformerDict[key]['parent'] if parent: dfm[1].setParent(parent) for param in deformerDict[key]['params'].keys(): attr = pm.Attribute(('%s.%s' % (dfm[0].name(), param))) if not attr.isArray(): attr.set(deformerDict[key]['params'][param]) for conn in deformerDict[key]['conns'].keys(): pm.Attribute(deformerDict[key]['conns'][conn]).connect( '%s.%s' % (dfm[0].name(), conn)) for g in geo: weightsFile = '%s_%s_weights.xml' % (g, key) pm.select(g) try: pm.deformerWeights(weightsFile, im=1, deformer=dfm[0], path=fileDir) except: print 'unable to load weights:\n\tdeformer: %s\n\tshape: %s\n\tweightsFile: %s' % ( dfm[0], g, weightsFile)
def bdAddTwist(self,surfaceRbn_BS): pm.select(surfaceRbn_BS) twistDef, twistDefTransform = pm.nonLinear(type='twist') twistDefTransform.rename(surfaceRbn_BS.name().replace('SRF_BS','twistHandle')) twistDef.rename(surfaceRbn_BS.name().replace('SRF_BS','twist')) twistDefTransform.rotateX.set(180) return twistDef, twistDefTransform
def build(name=None, crv=None, reg_node=None, log=False): """Create ine node deformer and attributes on given plane, and IK control connected to the reg_node. name -- Prefix name. Str crv -- Curve to add deformer to. nt.Transform reg_node -- registration node. nt.Transform """ general.check_type(name, "name", [str]) general.check_type(crv, "crv", [pm.nt.Transform]) general.check_type(reg_node, "reg_node", [pm.nt.Transform]) cnt_attr = "%s1_ik_cnt" % name if not hasattr(reg_node, cnt_attr): raise errors.InputError("reg_node", reg_node, "Missing attr: %s" % cnt_attr) attr = getattr(reg_node, cnt_attr) cnt = attr.listConnections()[0] if log: str_1 = "Cnt: ", cnt general.logging.debug(str_1) crv2 = crv.duplicate() sineDef, sineHndl = pm.nonLinear(crv2, typ="sine", name="%s_sineDeformer" % name) bs = pm.blendShape(crv2, crv, foc=True, name="%s_sineBlendShape" % name)[0] attr = getattr(bs, crv2[0].name()) attr.set(1) sineDef.rename("%s_sineDeformer" % name) sineHndl.rename("%s_sineDeformerHandle" % name) attrs = {"sineOffOn": [1, 0, 1], "amplitude": 0.3, "wavelength": 2, "offset": 0, "direction": 0} for attr in attrs.keys(): if isinstance(attrs[attr], list): pm.addAttr(cnt, ln=attr, dv=attrs[attr][0], min=attrs[attr][1], max=attrs[attr][2], k=1) else: pm.addAttr(cnt, ln=attr, dv=attrs[attr], k=1) cnt.sineOffOn >> sineDef.envelope cnt.amplitude >> sineDef.amplitude cnt.wavelength >> sineDef.wavelength cnt.offset >> sineDef.offset cnt.direction >> sineHndl.rotateY # Setup the handle hndl_grp = pm.group(name="%s_hndlGrp" % name, em=1) pm.parent(sineHndl, hndl_grp) sineHndl.rz.set(180) sineDef.dropoff.set(1) sineDef.lowBound.set(0) sineDef.highBound.set(2) control.register_object(reg_node, "sine_handle", sineHndl) return reg_node
def add_sine(self): nurbs_sine = pm.duplicate(self.nurbs, name='geo_' + self.ribbon_name + '_sine') # create sine deformer dfm_sine, tfm_sine = pm.nonLinear(nurbs_sine, type='sine') tfm_sine.setRotation([0, 0, 90], space='world') dfm_sine.dropoff.set(1) pm.blendShape(nurbs_sine, self.nurbs, weight=[0, 1])
def addTwist(self): pm.select(self.rbnBsSrf) twistDef, twistDefTransform = pm.nonLinear(self.rbnBsSrf, type='twist') twistDefTransform.rename(self.rbnName + '_srf_bs_twistHandle') twistDefTransform.scale.set( [self.rbnLength * 0.5, self.rbnLength * 0.5, self.rbnLength * 0.5]) twistDefTransform.hide() pm.parent(twistDefTransform, self.rbnNoTransformGrp) twistDef.rename(self.rbnName + '_srf_bs_twist') twistDefTransform.rotateZ.set(90) self.rbnTwist = twistDef print twistDefTransform, twistDefTransform.scale pm.select(cl=1)
def saveDeformers(): saveFilePath = pm.fileDialog2(fileFilter='*.json')[0] if saveFilePath: saveFileDir = '/'.join(saveFilePath.split('/')[:-1]) + '/' dfms = [dfm for dfm in pm.ls() if pm.nodeType(dfm) in deformerTypes] deformerDict = {} for dfm in dfms: key = dfm.name() handle = getHandle(dfm) deformerDict[key] = {} deformerDict[key]['nlType'] = getNonlinearType(dfm) deformerDict[key]['mtx'] = pm.xform(handle, q=1, ws=1, m=1) parent = None if handle.getParent(): parent = handle.getParent().name() deformerDict[key]['parent'] = parent deformerDict[key]['params'] = {} deformerDict[key]['geo'] = [ geo for geo in pm.nonLinear(dfm, q=1, geometry=1) ] for geo in deformerDict[key]['geo']: fileName = '%s_%s_weights.xml' % (geo, key) toSkip = [node.name() for node in dfms if not node == dfm] pm.deformerWeights(fileName, export=1, sh=geo, skip=toSkip, path=saveFileDir) attrs = [ a for a in pm.listAttr(dfm) if pm.Attribute('%s.%s' % (key, a)).isKeyable() and not 'weight' in a ] for attr in attrs: deformerDict[key]['params'][attr] = pm.getAttr( '%s.%s' % (dfm.name(), attr)) deformerDict[key]['conns'] = {} for attr in attrs: if not pm.Attribute('%s.%s' % (key, attr)).isArray(): conn = pm.listConnections('%s.%s' % (key, attr), plugs=1, d=0) if conn: deformerDict[key]['conns'][attr] = conn[0].name() with open(saveFilePath, 'w') as outfile: json.dump(deformerDict, outfile)
def createBend(self, obj, coords, parent=None): # bend1 pm.select(obj) bend = pm.nonLinear(type='bend') bendTransform = bend[1] bendTransform.translate.set(coords[0]) pm.xform(bendTransform, ro=coords[1], ws=1) pm.xform(bendTransform, ro=(0, 0, -90), os=1, r=1) bendScale = bendTransform.scaleX.get() * 2 bendTransform.scale.set(bendScale, bendScale, bendScale) bend[0].lowBound.set(0) if parent: bendTransform.setParent(parent) return bend
def extendPipe( jointLength=1 ): defaultLength = 3.0 currJnt = '' name = '' root = '' newJnts = [] for sel in pm.selected(): sel.select() # for now, there's no branching, so we find the deepest joint try: currJnt = sel name = currJnt.split('_')[0] root = pm.nt.Joint( '%s_Jnt0' % name ) except: raise "select an object on the pipe that you want to extend" # naming #---------- num = int(currJnt.extractNum()) try: twoPrev = int(currJnt.getParent().getParent().extractNum()) except: twoPrev = num-2 try: prev = int(currJnt.getParent().extractNum()) except: prev = num-1 curr = num new = int(currJnt.nextUniqueName().extractNum()) print "extending from", currJnt, new branchNum = len(currJnt.getChildren()) #print '%s has %s children' % (currJnt, branchNum) if branchNum: print "new segment is a branching joint" currJnt.addAttr( 'pipeLengthInBtwn%s' % branchNum, min=0 ) #currJnt.attr( 'pipeLengthInBtwn%s' % branchNum ).showInChannelBox(1) #print twoPrev, prev, curr, new rigGrp = '%s_RigGrp' % name geoGrp = '%s_GeoGrp' % name # new skeletal joint #--------------------- if new>1: prevJnt = pm.nt.Joint( '%s_Jnt%s' % (name, prev) ) pos = 2*currJnt.getTranslation(ws=1) - prevJnt.getTranslation(ws=1) else: prevJnt = None pos = currJnt.getTranslation(ws=1) + [0,defaultLength,0] newJnt = pm.joint( p=pos, n= '%s_Jnt%s' % (name, new) ) # re-orient the last created joint, which is considered our current joint pm.joint( currJnt, e=1, zeroScaleOrient=1, secondaryAxisOrient='yup', orientJoint='xyz') # pymel method: NEEDS FIXING #currJnt.setZeroScaleOrient(1) #currJnt.setSecondaryAxisOrient('yup') # Flag secondaryAxisOrient can only be used in conjunction with orientJoint flag. #currJnt.setOrientJoint('xyz') newJnt.scale.lock() newJnt.addAttr( 'pipeLength', defaultValue=jointLength, min=.0001 ) newJnt.pipeLength.showInChannelBox(1) newJnt.addAttr( 'pipeLengthInBtwn0', min=0 ) #newJnt.attr( 'pipeLengthInBtwn0' ).showInChannelBox(1) newJnt.addAttr( 'pipeLeadIn', dv=0, min=0 ) newJnt.pipeLeadIn.showInChannelBox(1) newJnt.addAttr( 'radiusMultiplier', dv=1, min=0 ) newJnt.radiusMultiplier.showInChannelBox(1) newJnt.displayHandle = 1 newJnt.radius.showInChannelBox(0) # bend hierarchy #----------------- trans = pm.group( empty=1, n='%s_Elbow%s' % (name, new)) trans.rotateOrder = 1 pm.aimConstraint( currJnt, trans, aimVector = [0, -1, 0], upVector = [-1, 0, 0] ) pm.pointConstraint( newJnt, trans ) trans.setParent( rigGrp ) # keep the end joint oriented along the joint chain so that it can be slid back # and forth to change the length of the current pipe segment pm.delete( pm.orientConstraint( trans, newJnt ) ) # Main Pipe #------------ pipe, pipeHist = pm.polyCylinder( height = 1, radius=1, name = '%s_Geo%s' % (name, new) ) pipeHist = pipeHist.rename( '%s_GeoHist%s' % (name, new) ) pipe.setPivots( [0, -.5, 0], r=1 ) root.globalPipeRadius >> pipe.sx root.globalPipeRadius >> pipe.sz pipeHist.createUVs = 3 # normalize and preserve aspect ratio root.subdivisionsAxis >> pipeHist.subdivisionsAxis # Pipe Connectors #------------- pipeConn1, pipeConnHist1 = pm.polyCylinder( height = .1, radius=1, name = '%s_Connector1AGeo%s' % (name, new) ) pipeConnHist1 = pipeConnHist1.rename( '%s_Connector1AHist%s' % (name, new) ) pipeConn1.setPivots( [0, -.05, 0], r=1 ) pipeConn1.setParent( pipe, relative=True ) pipeConn1.rotate.lock() root.subdivisionsAxis >> pipeConnHist1.subdivisionsAxis pipeConn2, pipeConnHist2 = pm.polyCylinder( height = .1, radius=1, name = '%s_Connector2AGeo%s' % (name, new) ) pipeConnHist2 = pipeConnHist2.rename( '%s_Connector2AHist%s' % (name, new) ) pipeConn2.setPivots( [0, .05, 0], r=1 ) pipeConn2.setParent( pipe, relative=True ) pipeConn2.rotate.lock() root.subdivisionsAxis >> pipeConnHist2.subdivisionsAxis pipeConn1, pipeConnHist1 = pm.polyCylinder( height = .1, radius=1, name = '%s_Connector1BGeo%s' % (name, new) ) pipeConnHist1 = pipeConnHist1.rename( '%s_Connector1BHist%s' % (name, new) ) pipeConn1.setPivots( [0, -.05, 0], r=1 ) pipeConn1.setParent( pipe, relative=True ) pipeConn1.rotate.lock() pipeConn1.visibility = 0 root.subdivisionsAxis >> pipeConnHist1.subdivisionsAxis pipeConn2, pipeConnHist2 = pm.polyCylinder( height = .1, radius=1, name = '%s_Connector2BGeo%s' % (name, new) ) pipeConnHist2 = pipeConnHist2.rename( '%s_Connector2BHist%s' % (name, new) ) pipeConn2.setPivots( [0, .05, 0], r=1 ) pipeConn2.setParent( pipe, relative=True ) pipeConn2.rotate.lock() pipeConn2.visibility = 0 root.subdivisionsAxis >> pipeConnHist2.subdivisionsAxis pipe.setParent( geoGrp ) #constraints pm.pointConstraint( currJnt, pipe ) aim = pm.aimConstraint( newJnt, pipe ) aim.offsetZ = -90 # convert the previous pipe joint into a bendy joint if new > 1: currElbow = pm.PyNode('%s_Elbow%s' % (name, curr) ) pipeLoc = pm.spaceLocator( n= '%s_PipeDummy%s' % (name, new) ) pipeLoc.hide() tweak = pm.group(n='%s_ElbowTweak%s' % (name, new)) tweak.rotateOrder = 2 #tweak.translate = currElbow.translate.get() tweak.setParent( currElbow, r=1 ) pm.aimConstraint( prevJnt, tweak, aimVector = [1, 0, 0], upVector = [0, -1, 0], skip=['z', 'x'] ) # Pipe Joint #------------ pipeJnt, pipeJntHist = pm.polyCylinder( height = 1, radius=1, name = '%s_JntGeo%s' % (name, new), subdivisionsAxis = 20, subdivisionsHeight = 30 ) pipeJnt.setParent( geoGrp ) pipeJnt.sy = jointLength pipeJnt.visibility = 0 pipeJntHist = pipeJntHist.rename( '%s_JntGeoHist%s' % (name, new) ) pipeJntHist.createUVs = 3 # normalize and preserve aspect ratio root.subdivisionsAxis >> pipeJntHist.subdivisionsAxis root.subdivisionsJoint >> pipeJntHist.subdivisionsHeight # constraints pm.parentConstraint( pipeLoc, pipeJnt ) pipeJnt.translate.lock() pipeJnt.rotate.lock() #pipeJnt.scale.lock() aim = pm.PyNode('%s_Elbow%s_aimConstraint1' % (name, curr)) aim.setWorldUpType( 2 ) aim.setWorldUpObject( newJnt ) bend, bendHandle = pm.nonLinear( '%s_JntGeo%s' % (name, new), type='bend' ) bendHandle = pm.nt.Transform(bendHandle).rename( '%s_BendHandle%s' % (name, new) ) bendHandle.sx =.5 bendHandle.hide() bend.rename( '%s_Bend%s' % (name, new) ) pm.parentConstraint( '%s_ElbowTweak%s' % (name, new), bendHandle ) aim = '%s_ElbowTweak%s_aimConstraint1' % (name, new) #aim.worldUpType.set( 1 ) pm.aimConstraint( aim, e=1, worldUpType='object', worldUpObject=newJnt ) bendHandle.setParent(rigGrp) expr = """ float $v1[]; $v1[0] = %(name)s_Elbow%(twoPrev)s.translateX - %(name)s_Elbow%(prev)s.translateX; $v1[1] = %(name)s_Elbow%(twoPrev)s.translateY - %(name)s_Elbow%(prev)s.translateY; $v1[2] = %(name)s_Elbow%(twoPrev)s.translateZ - %(name)s_Elbow%(prev)s.translateZ; float $v2[]; $v2[0] = %(name)s_Elbow%(curr)s.translateX - %(name)s_Elbow%(prev)s.translateX; $v2[1] = %(name)s_Elbow%(curr)s.translateY - %(name)s_Elbow%(prev)s.translateY; $v2[2] = %(name)s_Elbow%(curr)s.translateZ - %(name)s_Elbow%(prev)s.translateZ; float $mag = sqrt ( $v2[0]*$v2[0] + $v2[1]*$v2[1] + $v2[2]*$v2[2] ); float $angleData[] = `angleBetween -v1 $v1[0] $v1[1] $v1[2] -v2 $v2[0] $v2[1] $v2[2] `; float $angle = $angleData[3]; if ( !equivalentTol($angle,180.0, 0.1) ) { float $jointDeg = 180 - $angle; float $jointRad = -1 * deg_to_rad( $jointDeg ); %(name)s_Bend%(curr)s.curvature = $jointRad/2; %(name)s_ElbowTweak%(curr)s.rotateZ = $jointDeg/2; %(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s = %(name)s_Jnt%(prev)s.pipeLength; float $pipeLength = %(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s; float $centerAngleRad = deg_to_rad(90 -$angle/2); float $delta = 0; float $pipeLengthRatio = 1; if ($centerAngleRad > 0.0) { float $radius = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s/ $centerAngleRad; $delta = $radius - ($radius * cos( $centerAngleRad )); $pipeLengthRatio = .5 * $pipeLength / ( $radius * sin( $centerAngleRad ) ); $pipeLength *= $pipeLengthRatio; } %(name)s_PipeDummy%(curr)s.translateX = -1*$delta; %(name)s_BendHandle%(curr)s.scaleX = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s; %(name)s_BendHandle%(curr)s.scaleY = %(name)s_BendHandle%(curr)s.scaleX; %(name)s_BendHandle%(curr)s.scaleZ = %(name)s_BendHandle%(curr)s.scaleX; %(name)s_JntGeo%(curr)s.scaleY = $pipeLength * (1.0+%(name)s_Jnt%(curr)s.pipeLeadIn); %(name)s_JntGeo%(curr)s.scaleX = %(name)s_Jnt0.globalPipeRadius + %(name)s_Jnt0.globalJointRadius; %(name)s_JntGeo%(curr)s.scaleZ = %(name)s_JntGeo%(curr)s.scaleX; %(name)s_JntGeo%(curr)s.visibility = 1; %(name)s_Connector1BGeo%(curr)s.visibility=1; %(name)s_Connector2BGeo%(curr)s.visibility=1; } else { %(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s = 0; %(name)s_JntGeo%(curr)s.scaleY = 0; %(name)s_JntGeo%(curr)s.visibility = 0; %(name)s_Connector1BGeo%(curr)s.visibility=0; %(name)s_Connector2BGeo%(curr)s.visibility=0; } %(name)s_Connector1AGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * (1/%(name)s_Geo%(curr)s.scaleY); %(name)s_Connector2AGeo%(curr)s.scaleY = %(name)s_Connector1AGeo%(curr)s.scaleY; %(name)s_Connector1AGeo%(curr)s.translateY = -.5 + %(name)s_Connector1AHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset; %(name)s_Connector2AGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1AHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset; %(name)s_Connector1AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector1AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector1BGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * (1/%(name)s_Geo%(curr)s.scaleY); %(name)s_Connector2BGeo%(curr)s.scaleY = %(name)s_Connector1BGeo%(curr)s.scaleY; %(name)s_Connector1BGeo%(curr)s.translateY = -.5 + %(name)s_Connector1BHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset - .1*%(name)s_Connector1BGeo%(curr)s.scaleY; %(name)s_Connector2BGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1BHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset + .1*%(name)s_Connector1BGeo%(curr)s.scaleY; %(name)s_Connector1BGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector1BGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2BGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2BGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Geo%(curr)s.scaleY = $mag - .5*%(name)s_Jnt%(curr)s.pipeLengthInBtwn0 - .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s; normalize($v2); %(name)s_Geo%(curr)s_pointConstraint1.offsetX = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[0]; %(name)s_Geo%(curr)s_pointConstraint1.offsetY = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[1]; %(name)s_Geo%(curr)s_pointConstraint1.offsetZ = .5*%(name)s_Jnt%(prev)s.pipeLengthInBtwn%(branch)s * $v2[2]; """ % { 'twoPrev' : prev, 'prev' : curr, 'curr' : new, 'new' : new+1, 'name': name, 'branch': branchNum } #print expr print 'editing %s_PipeExpr%s' % (name, new) #expression( '%s_PipeExpr%s' % (name, curr), e=1, s=expr, ae=1 ) pm.expression( s=expr, ae=1, n = '%s_PipeExpr%s' % (name, new) ) # special case for first joint else: expr = """ float $x = %(newJnt)s.tx; float $y = %(newJnt)s.ty; float $z = %(newJnt)s.tz; float $mag = sqrt ( $x*$x + $y*$y + $z*$z ); %(name)s_Geo%(curr)s.sy = $mag - .5*%(newJnt)s.pipeLengthInBtwn0; %(name)s_Connector1AGeo%(curr)s.scaleY = %(name)s_Jnt0.globalConnectorThickness * 1/%(name)s_Geo%(curr)s.scaleY; %(name)s_Connector2AGeo%(curr)s.scaleY = %(name)s_Connector1AGeo%(curr)s.scaleY; %(name)s_Connector1AGeo%(curr)s.translateY = -.5 + %(name)s_Connector1AHist%(curr)s.height/2 + .1*%(name)s_Jnt0.globalConnectorOffset; %(name)s_Connector2AGeo%(curr)s.translateY = 0.5 - %(name)s_Connector1AHist%(curr)s.height/2 - .1*%(name)s_Jnt0.globalConnectorOffset; %(name)s_Connector1AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector1AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2AGeo%(curr)s.scaleX = 1 + %(name)s_Jnt0.globalConnectorRadius; %(name)s_Connector2AGeo%(curr)s.scaleZ = 1 + %(name)s_Jnt0.globalConnectorRadius; """ % { 'newJnt': newJnt, 'curr' : new, 'name': name } print 'creating %s_PipeExpr1' % (name) pm.expression( s=expr, ae=1, n = '%s_PipeExpr1' % (name)) ''' expr = """ %(pipeJnt)s.scaleX = %(root)s.globalPipeRadius + %(root)s.globalJointRadius; %(pipeJnt)s.scaleZ = %(pipeJnt)s.scaleX; """ % { 'pipeJnt': pipeJnt, 'root' : '%s_Jnt0' % (name) } print 'creating %s_PipeExpr%s' % (name, new) expression( s=expr, ae=1, n = '%s_PipeExpr%s' % (name, new)) ''' pipe.translate.lock() pipe.rotate.lock() #pipe.scale.lock() newJnts.append( newJnt ) pm.select(newJnts)
def addVolume(self): self.rbnVolSrf = pm.duplicate(self.rbnSrf, name=self.rbnName + '_vol_srf')[0] pm.parent(self.rbnVolSrf, self.rbnNoTransformGrp) self.rbnSquash, rbnSquashTransform = pm.nonLinear(type='squash') rbnSquashTransform.rename(self.rbnName + '_vol_srf_squashHandle') pm.parent(rbnSquashTransform, self.rbnNoTransformGrp) self.rbnSquash.rename(self.rbnName + '_vol_srf_squash') rbnSquashTransform.rotateZ.set(90) self.rbnVolFlcGrp = self.createFlcs(self.rbnVolSrf) pm.xform(self.rbnVolSrf, t=[0, 0, -0.5 * self.rbnWidth]) pm.xform(rbnSquashTransform, t=[0, 0, -0.5 * self.rbnWidth]) # Add volume attributes on the rbn trs pm.addAttr(self.rbnCtrl, ln='volumeAttr', nn='------', at='enum', en='Volume:', keyable=1) self.rbnCtrl.volumeAttr.lock() pm.addAttr(self.rbnCtrl, ln='enableVolume', nn='Enable', at='double', min=0, max=1, dv=0, keyable=1) pm.addAttr(self.rbnCtrl, ln='multiplyVolume', nn='Multiply', at='double', dv=0.7, keyable=1) pm.addAttr(self.rbnCtrl, ln='smoothVolume', nn='Smooth', at='double', min=0, max=1, dv=1, keyable=1) self.rbnCtrl.smoothVolume.connect(self.rbnSquash.startSmoothness) self.rbnCtrl.smoothVolume.connect(self.rbnSquash.endSmoothness) # drive the original surface follicles scale based on the translate Z of the vol follicles ( well, not the folicle , but the controler under it, the folicle has the global scale on it) folicles = self.rbnVolFlcGrp.listRelatives(c=True, type='transform') for flc in folicles: flcShape = flc.getShape() if (self.rbnDirection == 'v'): flcShape.parameterU.set(0.0) else: flcShape.parameterV.set(0.0) self.connectFlc(folicles.index(flc)) rbnSquashTransform.hide() self.rbnVolFlcGrp.hide() self.rbnVolSrf.hide() # drive the suqash deformer factor with the scale of the ribbon wireCrvInfo = pm.shadingNode('curveInfo', asUtility=1, name=self.rbnWireCrv.name() + '_ci') self.rbnWireCrv.getShape().worldSpace.connect(wireCrvInfo.inputCurve) self.rbnScaleRefCrv = pm.duplicate(self.rbnWireCrv, name=self.rbnName + '_scl_crv')[0] crvInfo = pm.shadingNode('curveInfo', asUtility=1, name=self.rbnScaleRefCrv.name() + '_ci') self.rbnScaleRefCrv.getShape().worldSpace.connect(crvInfo.inputCurve) scaleFactorMd = pm.shadingNode('multiplyDivide', au=1, name=self.rbnWireCrv.name() + '_scale_factor_md') scaleFactorMd.operation.set(2) wireCrvInfo.arcLength.connect(scaleFactorMd.input1X) crvInfo.arcLength.connect(scaleFactorMd.input2X) zeroFactorAdl = pm.shadingNode('addDoubleLinear', au=1, name=self.rbnWireCrv.name() + '_zerofactor_adl') zeroFactorAdl.input2.set(-1) scaleFactorMd.outputX.connect(zeroFactorAdl.input1) enableVolMdl = pm.shadingNode('multDoubleLinear', au=1, name=self.rbnName + '_enable_volume_mdl') self.rbnCtrl.enableVolume.connect(enableVolMdl.input1) zeroFactorAdl.output.connect(enableVolMdl.input2) enableVolMdl.output.connect(self.rbnSquash.factor)
blendNode = pm.blendShape(curveToWrap, hairNew, frontOfChain = True, name = "BS_hair_curves" ) print(blendNode) # connect to controller pm.connectAttr('M_head_up_02_ctrl.HairPop', '%s.hair_curves_bs' % blendNode[0].nodeName()) ############################################################################ start step 3: blenshape connection ############################################################################ start step 4: connect squash and stretch ## ======================================================================== apply squash and stretch headSquash = pm.ls('head_squash_Handle', r = 1)[0] headBendRL = pm.ls('bend_headRL_Handle', r = 1)[0] headBendFB = pm.ls('bend_headFB_Handle', r = 1)[0] toSquashCurves = pm.PyNode('hair_curves') pm.nonLinear(headSquash, e = True, g = toSquashCurves) pm.nonLinear(headBendRL, e = True, g = toSquashCurves) pm.nonLinear(headBendFB, e = True, g = toSquashCurves) ############################################################################ end step 4: connect squash and stretch ## ========================================================================= select curves to geocacheset (bake4hair) setTmp = pm.listRelatives('hair_curves', allDescendents = True, type = 'transform') geoCacheSet = [] for elt in setTmp: if elt.getShape(): geoCacheSet.append(elt) pm.select(geoCacheSet)
def doRig(self): nurbsSurf = pm.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=self.width, lr=0.1, d=3, u=self.div, v=1, ch=0, n=self.flexName + 'FlexNurbsSrf')[0] nurbsSurf.visibility.set(False) nurbsSurf.translate.set(self.width / 2, 0, 0) spacing = 1.0 / float(self.div) start = spacing / 2.0 grp1 = pm.group(n=self.flexName + 'Folicules_grp', empty=True) grp2 = pm.group(em=True, n=self.flexName + 'ribbonGlobalMove') grp3 = pm.group(em=True, n=self.flexName + 'FlexNoMove') for i in range(int(self.div)): foll = self.createFoll(self.flexName + 'Follicle' + str('%02d' % i), nurbsSurf, start + spacing * i, 0.5) jnt1 = pm.joint(p=(0, 0, 0), n=self.flexName + str('%02d' % i) + '_jnt') pm.move(0, 0, 0, jnt1, ls=True) pm.parent(foll, grp1) nurbsSurfBlend = pm.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=self.width, lr=0.1, d=3, u=self.div, v=1, ch=0, n=self.flexName + 'FlexBlendNurbsSrf')[0] nurbsSurfBlend.translate.set(self.width / 2, 0, 0) pm.blendShape(nurbsSurfBlend, nurbsSurf, frontOfChain=True, tc=0, w=(0, 1)) crv = pm.curve(d=2, p=[((self.width * -0.5), 0, 0), (0, 0, 0), ((self.width * 0.5), 0, 0)], k=[0, 0, 1, 1], n=self.flexName + 'Crv') crv.translate.set(self.width / 2, 0, 0) cls1 = pm.cluster(crv + '.cv[0]', crv + '.cv[1]', rel=True, n=self.flexName + 'Cls1') pm.move((self.width * -0.5), 0, 0, cls1[1] + '.scalePivot', cls1[1] + '.rotatePivot') cls2 = pm.cluster(crv + '.cv[2]', crv + '.cv[1]', rel=True, n=self.flexName + 'Cls2') pm.move((self.width * 0.5), 0, 0, cls2[1] + '.scalePivot', cls2[1] + '.rotatePivot') cls3 = pm.cluster(crv + '.cv[1]', rel=True, n=self.flexName + 'Cls3') pm.percent(cls1[0], crv + '.cv[1]', v=0.5) pm.percent(cls2[0], crv + '.cv[1]', v=0.5) twist = pm.nonLinear(nurbsSurfBlend, type='twist', n=self.flexName + 'Twist') twist[1].rotate.set(0, 0, 90) wir = pm.wire(nurbsSurfBlend, gw=False, en=1.000000, ce=0.000000, li=0.000000, w=crv, dds=(0, 20)) wireNode = pm.PyNode(wir[0]) baseWire = [x for x in wireNode.connections() if 'BaseWire' in x.name()] cntrl1 = controlTools.cntrlCrv(name=self.flexName + 'aux1', icone='grp') cntrl2 = controlTools.cntrlCrv(name=self.flexName + 'aux2', icone='grp') cntrl3 = controlTools.cntrlCrv(name=self.flexName + 'aux3', icone='grp') pos = pm.pointOnSurface(nurbsSurfBlend, u=0.0, v=0.5) cntrl1.getParent().translate.set(pos) pos = pm.pointOnSurface(nurbsSurfBlend, u=1.0, v=0.5) cntrl2.getParent().translate.set(pos) pos = pm.pointOnSurface(nurbsSurfBlend, u=0.5, v=0.5) cntrl3.getParent().translate.set(pos) cntrl1.addAttr('twist', at='float', dv=0, k=1) cntrl2.addAttr('twist', at='float', dv=0, k=1) pm.pointConstraint(cntrl1, cntrl2, cntrl3.getParent()) cntrl1.translate >> cls1[1].translate cntrl2.translate >> cls2[1].translate cntrl3.translate >> cls3[1].translate cntrl2.twist >> twist[0].startAngle cntrl1.twist >> twist[0].endAngle pm.parent(nurbsSurf, cntrl1.getParent(), cntrl2.getParent(), cntrl3.getParent(), grp2) pm.parent(grp1, nurbsSurfBlend, cls1[1], cls2[1], cls3[1], baseWire, crv, twist[1], grp3) pm.setAttr(grp3 + '.visibility', 0) # pm.group (grp1,grp2,grp3,n=self.flexName+'Flex_grp') # implementar squash/stretch # implementar o connect to limb
def build(name=None, crv=None, reg_node=None, log=False): '''Create ine node deformer and attributes on given plane, and IK control connected to the reg_node. name -- Prefix name. Str crv -- Curve to add deformer to. nt.Transform reg_node -- registration node. nt.Transform ''' general.check_type(name, 'name', [str]) general.check_type(crv, 'crv', [pm.nt.Transform]) general.check_type(reg_node, 'reg_node', [pm.nt.Transform]) cnt_attr = '%s1_ik_cnt' % name if not hasattr(reg_node, cnt_attr): raise errors.InputError('reg_node', reg_node, 'Missing attr: %s' % cnt_attr) attr = getattr(reg_node, cnt_attr) cnt = attr.listConnections()[0] if log: str_1 = 'Cnt: ', cnt general.logging.debug(str_1) crv2 = crv.duplicate() sineDef, sineHndl = pm.nonLinear(crv2, typ='sine', name='%s_sineDeformer' % name) bs = pm.blendShape(crv2, crv, foc=True, name='%s_sineBlendShape' % name)[0] attr = getattr(bs, crv2[0].name()) attr.set(1) sineDef.rename('%s_sineDeformer' % name) sineHndl.rename('%s_sineDeformerHandle' % name) attrs = { 'sineOffOn': [1, 0, 1], 'amplitude': 0.3, 'wavelength': 2, 'offset': 0, 'direction': 0 } for attr in attrs.keys(): if isinstance(attrs[attr], list): pm.addAttr(cnt, ln=attr, dv=attrs[attr][0], min=attrs[attr][1], max=attrs[attr][2], k=1) else: pm.addAttr(cnt, ln=attr, dv=attrs[attr], k=1) cnt.sineOffOn >> sineDef.envelope cnt.amplitude >> sineDef.amplitude cnt.wavelength >> sineDef.wavelength cnt.offset >> sineDef.offset cnt.direction >> sineHndl.rotateY # Setup the handle hndl_grp = pm.group(name='%s_hndlGrp' % name, em=1) pm.parent(sineHndl, hndl_grp) sineHndl.rz.set(180) sineDef.dropoff.set(1) sineDef.lowBound.set(0) sineDef.highBound.set(2) control.register_object(reg_node, 'sine_handle', sineHndl) return reg_node
def flexiplane(self, prefix=''): """ Build FlexiPlane :param index: number of flexiplane in scene (auto managed by maya) :return: FlexiPlane group node """ fp_name = '%sflexiPlane' % prefix fp_name = nameCheck.nameCheck(fp_name + '*_GRP').replace( '_GRP', '', 1) # flexiPlane_GRP fp_surf = self.create_plane('%s_NURBS' % (fp_name))[0] fp_surf.overrideEnabled.set(1) fp_surf.overrideDisplayType.set(2) # Assign Material self.create_lambret(fp_surf, color=(0.067, 0.737, 0.749), transparency=(0.75, 0.75, 0.75)) # Create Follicles # flc_name = 'flexiPlane' v = 0.1 # 1/width flcs = [] how_many_flc = 5 # width/2 for i in range(0, how_many_flc): ofoll = self.create_follicle( fp_surf, '%s_flc_%s_FLC' % (fp_name, letters[i + 26]), v, 0.5) flcs.append(ofoll) v += 0.2 # (1/width)*2 # Group Follicles flc_grp = pm.group(flcs, name='%s_flcs_GRP' % (fp_name)) # creates flexiPlane controls curves at each end self.ctrl_a = self.ctrl_square(name='%s_ctrl_a_CTRL' % (fp_name), pos=[-5, 0, 0]) ctrl_ashape = self.ctrl_a.getShape() pm.rename(ctrl_ashape, '%sShape' % self.ctrl_a) self.ctrl_b = self.ctrl_square(name='%s_ctrl_b_CTRL' % (fp_name), pos=[5, 0, 0]) ctrl_bshape = self.ctrl_b.getShape() pm.rename(ctrl_bshape, '%sShape' % self.ctrl_b) pm.select(cl=True) # creates flexiPlane blendshape # blendshape suffix: _bShp_ fp_bshp = pm.duplicate(fp_surf, n='%s_bshp_NURBS' % (fp_name))[0] pm.move(0, 0, -5, fp_bshp) fps_bshp_node = pm.blendShape(fp_bshp, fp_surf, n='%s_BSHP' % (fp_name))[0] pm.setAttr('%s.%s' % (fps_bshp_node, fp_bshp), 1) # pm.rename('tweak1', '%sbshp_%stweak_01' % (fp_name, sur)) # creates curve for wire deformer fp_curve = pm.curve(d=2, p=[(-5, 0, -5), (0, 0, -5), (5, 0, -5)], k=[0, 0, 1, 1], n='%s_wire_CV' % (fp_name)) cl_a, cl_b, cl_mid = self.cluster_curve(fp_curve, fp_name) # create and place twist deformer pm.select(fp_bshp) fp_twist = pm.nonLinear(type='twist', lowBound=-1, highBound=1) # displays warning: pymel.core.general : could not create desired mfn. Defaulting MfnDependencyNode. # doesn't seem to affect anything though pm.rename(fp_twist[0], '%s_twistAttr_surface_NURBS' % (fp_name)) pm.rename(fp_twist[1], '%s_twist_Handle_DEFORMER' % (fp_name)) fp_twist[1].rz.set(90) # connect start and end angle to their respective control connect = self.ctrl_b.rx >> fp_twist[0].startAngle connect = self.ctrl_a.rx >> fp_twist[0].endAngle # skins wire to blendshape fp_wire = pm.wire( fp_bshp, w=fp_curve, gw=False, en=1, ce=0, li=0, # dds=(0, 20), n='%s_wireAttrs_DEFORMER' % (fp_name)) fp_wire[0].dropoffDistance[0].set(20) hist = pm.listHistory(fp_surf) tweaks = [t for t in hist if 'tweak' in t.nodeName()] pm.rename(tweaks[2], '%s_cl_cluster_tweak' % (fp_name)) pm.rename(tweaks[0], '%s_wireAttrs_tweak' % (fp_name)) pm.rename(tweaks[1], '%s_extra_tweak' % (fp_name)) # group clusters cl_grp = pm.group(cl_a[1], cl_b[1], cl_mid[1], n='%s_cls_GRP' % (fp_name)) util.lock_and_hide_all(cl_grp) # creates mid control self.ctrl_mid = self.flexiplane_mid_ctrl(name='%s_ctrl_mid_CTRL' % (fp_name)) ctrl_mid_grp = pm.group(self.ctrl_mid, n='%s_grp_midBend_GRP' % (fp_name)) pm.pointConstraint(self.ctrl_a, self.ctrl_b, ctrl_mid_grp, o=[0, 0, 0], w=1) # groups controls together and locks and hides group attributes ctrl_grp = pm.group(self.ctrl_a, self.ctrl_b, ctrl_mid_grp, n='%s_ctrl_GRP' % (fp_name)) util.lock_and_hide_all(ctrl_grp) # connecting translate attrs of control curves for to the clusters connect = [] connect.append(self.ctrl_a.t >> cl_a[1].t) connect.append(self.ctrl_b.t >> cl_b[1].t) connect.append(self.ctrl_mid.t >> cl_mid[1].t) # makes mid_ctrl, flexiPlane and blendShape surfaces non renderable util.no_render(fp_surf) util.no_render(fp_bshp) util.no_render(self.ctrl_mid) # groups everything under 1 group then locks and hides the transform attrs of that group #flexiPlane_wire_surface0101BaseWire self.fp_grp = pm.group( fp_surf, flc_grp, fp_bshp, fp_wire, # '%s_wire_%s_BaseWire_GRP' % (fp_name, self.surfaceSuffix), cl_grp, ctrl_grp, n='%s_GRP' % (fp_name)) util.lock_and_hide_all(self.fp_grp) # creates global move group and extraNodes fp_gm_grp = pm.group(fp_surf, ctrl_grp, n='%s_globalMove_GRP' % (fp_name)) fp_xnodes_grp = pm.group(flc_grp, fp_bshp, fp_wire, '%s_wire_CVBaseWire' % (fp_name), cl_grp, n='%s_extraNodes_GRP' % (fp_name)) pm.parent(fp_twist, fp_xnodes_grp) pm.parent(fp_xnodes_grp, self.fp_grp) fp_xnodes_grp.overrideEnabled.set(1) fp_xnodes_grp.overrideDisplayType.set(2) # scale constrains follicles to global move group for follicle in flcs: mparent = follicle.getParent() pm.scaleConstraint(fp_gm_grp, mparent) # creates global move control self.fp_gm_ctrl = self.global_ctrl(name=fp_name) # moves global control into flexiPlane group then parent global move group to global move control. pm.parent(self.fp_gm_ctrl, self.fp_grp) pm.parent(fp_gm_grp, self.fp_gm_ctrl) # joints placement jnts = [] for i in range(0, len(flcs)): posx = round(flcs[i].getParent().translateX.get(), 4) jnt = pm.joint(p=(posx, 0, 0), rad=0.5, n='%sbind_%s_JNT' % (fp_name, letters[i + 26])) jnts.append(jnt) # parent joint under follicle pm.parent(jnt, flcs[i].getParent()) # locks and hides transformNodes flexiPlane surface util.lock_and_hide_all(fp_surf) # hides blendShape, clusters and twist Deformer fp_twist[1].visibility.set(0) cl_grp.visibility.set(0) fp_bshp.visibility.set(0) fp_curve.visibility.set(0) # selects the wire deformer and creates a curve info node... # ...to get the wire deformers length pm.select(fp_curve, r=True) length = pm.arclen(ch=1) length.rename('%scurveInfo_DEFORMER' % (fp_name)) # creates a multiplyDivideNode for squashStretch length... # ...and sets it operation to divide fp_div = pm.createNode('multiplyDivide', n='%sdiv_squashStretch_length' % (fp_name)) fp_div.operation.set(2) # secondary multDivNode for volume, sets input1X to 1 fp_div_vol = pm.createNode('multiplyDivide', n='%sdiv_volume' % (fp_name)) fp_div_vol.operation.set(2) fp_div_vol.input1X.set(1) # creates a conditionNode for global_ctrl enable attr fp_cond = pm.createNode('condition', n='%scond_volume' % (fp_name)) fp_cond.secondTerm.set(1) # connects curve all the nodes connect = length.arcLength >> fp_div.input1.input1X fp_div.input2.input2X.set(10) connect = fp_div.outputX >> fp_div_vol.input2.input2X connect = self.fp_gm_ctrl.enable >> fp_cond.firstTerm connect = fp_div_vol.outputX >> fp_cond.colorIfTrueR fp_ctrl_global = self.fp_gm_ctrl.getShape() for i in range(0, len(flcs)): connect = fp_cond.outColorR >> jnts[i].sy connect = fp_cond.outColorR >> jnts[i].sz flcs[i].visibility.set(0) # hides blendShape, clusters and twist Deformer fp_twist[1].visibility.set(0) cl_grp.visibility.set(0) fp_bshp.visibility.set(0) fp_curve.visibility.set(0) pm.select(self.fp_gm_ctrl, r=True) return self.fp_gm_ctrl
def addOperators(self): """Create operators and set the relations for the component rig Apply operators, constraints, expressions to the hierarchy. In order to keep the code clean and easier to debug, we shouldn't create any new object in this method. """ host = self.getHost() if not host: host = self.root # IK Chain ----------------------------------------- # Drive ik crv points self.dm = [] for i in range(len(self.ik_ctl)): num = str(i + 1).zfill(2) d = pm.createNode('decomposeMatrix', name=self.getName('ikCtl_%s_worldMtx2Srt_utl' % num)) self.ik_ctl[i].worldMatrix[0].connect(d.inputMatrix) d.outputTranslate.connect(self.ikCrv.controlPoints[i]) self.dm.append(d) # Drive aimers -------------------------------------- ang = pm.createNode('angleBetween', name=self.getName('_startAim_angle_utl')) startLocalVec = pm.createNode('vectorProduct', name=self.getName('_startVec_utl')) self.dm[1].outputTranslate.connect(startLocalVec.input1) self.ik_cns.worldInverseMatrix[0].connect(startLocalVec.matrix) startLocalVec.operation.set(4) startLocalVec.output.connect(ang.vector2) ang.vector1.set(1, 0, 0) ang.euler.connect(self.aim_loc.r) ang = pm.createNode('angleBetween', name=self.getName('_endAim_angle_utl')) endLocalVec = pm.createNode('vectorProduct', name=self.getName('_endVec_utl')) self.dm[-2].outputTranslate.connect(endLocalVec.input1) self.ik_ctl[-1].worldInverseMatrix[0].connect(endLocalVec.matrix) endLocalVec.operation.set(4) endLocalVec.output.connect(ang.vector2) ang.vector1.set(-1, 0, 0) ang.euler.connect(self.aim_end_loc.r) # Drive ik rail points ----------------------------- self.ikRailMp = [] for i in range(numSamples): num = str(i + 1).zfill(2) param = (1.0 / (numSamples - 1)) * i mp = pm.createNode('motionPath', name=self.getName('ikCrv_%s_mp_utl' % num)) self.ikCrv.worldSpace[0].connect(mp.geometryPath) mp.uValue.set(param) mp.fractionMode.set(1) mp.frontAxis.set(0) mp.upAxis.set(1) mp.follow.set(1) mp.worldUpType.set(2) vp = pm.createNode('vectorProduct', name=self.getName('ikRail_%s_upVec_utl' % num)) vp.operation.set(3) vp.normalizeOutput.set(1) vp.input1Y.set(1) if not i: self.aim_loc.worldMatrix[0].connect(mp.worldUpMatrix) self.aim_loc.worldMatrix[0].connect(vp.matrix) else: self.ikRailMp[-1].orientMatrix.connect(vp.matrix) self.ikRailMp[-1].orientMatrix.connect(mp.worldUpMatrix) pma = pm.createNode('plusMinusAverage', name=self.getName('ikRail_%s_pos_utl' % num)) md = pm.createNode('multiplyDivide', name=self.getName('ikRail_%s_upVecMult_utl' % num)) md.input2.set((.1, .1, .1)) vp.output.connect(md.input1) md.output.connect(pma.input3D[0]) mp.allCoordinates.connect(pma.input3D[1]) pma.output3D.connect(self.ikRailCrv.controlPoints[i]) self.ikRailMp.append(mp) # Twist -------------------------------------------- mpUp = pm.createNode('motionPath', name=self.getName('twist_upMp_utl')) self.ikRailCrv.worldSpace[0].connect(mpUp.geometryPath) mpUp.uValue.set(1.0) twistVec = pm.createNode('vectorProduct', name=self.getName('twistVec_utl')) mpUp.allCoordinates.connect(twistVec.input1) self.aim_end_loc.worldInverseMatrix[0].connect(twistVec.matrix) twistVec.operation.set(4) twistAng = pm.createNode('angleBetween', name=self.getName('twistAngle_utl')) twistVec.output.connect(twistAng.vector1) twistAng.vector2.set(0, 1, 0) twistSign = pm.createNode('condition', name=self.getName('twistSign_utl')) twistVec.outputZ.connect(twistSign.firstTerm) twistSign.operation.set(2) twistSign.colorIfTrueR.set(-1) signedTwist = pm.createNode('animBlendNodeAdditiveDA', name=self.getName('twistResult_utl')) twistAng.angle.connect(signedTwist.inputA) twistSign.outColorR.connect(signedTwist.weightA) # FK Chain ----------------------------------------- self.fk_mtx = [] print 'fk mpo: %s' % self.fk_npo for i in range(self.settings['num_fk_ctls']): num = str(i + 1).zfill(2) param = (1.0 / (self.settings['num_fk_ctls'] - 1)) * i mp = pm.createNode('motionPath', name=self.getName('ikCrv_%s_mp_utl' % num)) mp.fractionMode.set(1) mp.follow.set(1) mp.frontAxis.set(0) mp.upAxis.set(1) mp.worldUpType.set(1) self.ikCrv.worldSpace[0].connect(mp.geometryPath) mp.uValue.set(param) mpUp = pm.createNode('motionPath', name=self.getName('ikCrv_%s_mp_utl' % num)) self.ikRailCrv.worldSpace[0].connect(mpUp.geometryPath) mpUp.uValue.set(param) mtxUp = pm.createNode('composeMatrix', name=self.getName('ikCrv_%s_upMtx_utl' % num)) mpUp.allCoordinates.connect(mtxUp.inputTranslate) mtxUp.outputMatrix.connect(mp.worldUpMatrix) wMtx = pm.createNode('composeMatrix', name=self.getName('ikCrv_%s_worldMtx_utl' % num)) mp.allCoordinates.connect(wMtx.inputTranslate) mp.rotate.connect(wMtx.inputRotate) self.fk_mtx.append(wMtx) if not i: mp.allCoordinates.connect(self.fk_npo[i].t) mp.rotate.connect(self.fk_npo[i].r) else: localMtx = pm.createNode('multMatrix', name=self.getName( 'ikCrv_%s_localMtx_utl' % num)) wMtx.outputMatrix.connect(localMtx.matrixIn[0]) iMtx = pm.createNode('inverseMatrix', name='ikCrv_%s_worldInverseMtx_utl' % num) self.fk_mtx[i - 1].outputMatrix.connect(iMtx.inputMatrix) iMtx.outputMatrix.connect(localMtx.matrixIn[1]) self.fk_ctl[i - 1].worldMatrix[0].connect(localMtx.matrixIn[2]) d = pm.createNode('decomposeMatrix', name=self.getName('ikCrv_%s_mtx2Srt_utl' % num)) localMtx.matrixSum.connect(d.inputMatrix) d.outputTranslate.connect(self.fk_npo[i].t) d.outputRotate.connect(self.fk_npo[i].r) twistMult = pm.createNode('animBlendNodeAdditiveDA', name=self.getName( 'ikCrv_%s_twistMult_utl' % num)) twistMult.weightA.set( (1.0 / (self.settings['num_fk_ctls'] - 1)) * i) signedTwist.output.connect(twistMult.inputA) twistMult.output.connect(mp.frontTwist) # Drive fk crv points self.fk_dm = [] for i in range(len(self.fk_ctl)): num = str(i + 1).zfill(2) d = pm.createNode('decomposeMatrix', name=self.getName('fkCtl_%s_worldMtx2Srt_utl' % num)) self.fk_ctl[i].worldMatrix[0].connect(d.inputMatrix) d.outputTranslate.connect(self.fkCrv.controlPoints[i]) self.fk_dm.append(d) # Drive avg nodes pb = pm.createNode('pairBlend', name=self.getName('fkAvg_%s_utl' % num)) self.fk_ctl[i].r.connect(pb.inRotate2) self.fk_ctl[i].roll.connect(pb.inRotateX1) pb.weight.set(0.5) pb.outRotate.connect(self.fk_avg[i].r) # FK rail crv points vp = pm.createNode('vectorProduct', name=self.getName('fkRailPoint_%s_utl' % num)) self.fk_avg[i].worldMatrix[0].connect(vp.matrix) vp.input1.set(0, 0.1, 0) vp.operation.set(4) vp.output.connect(self.fkRailCrv.controlPoints[i]) # Stretch -------------------------------------------- self.crvInfo = pm.createNode('curveInfo', name=self.getName('fk_crvInfo_utl')) self.fkCrv.worldSpace[0].connect(self.crvInfo.inputCurve) stretchScaled = pm.createNode('multiplyDivide', name=self.getName('fk_crvLenScaled_utl')) stretchScaled.operation.set(2) self.dm[0].outputScaleX.connect(stretchScaled.input1X) self.crvInfo.arcLength.connect(stretchScaled.input2X) stretch = pm.createNode('multiplyDivide', name=self.getName('fk_crvStretch_utl')) stretchScaled.outputX.connect(stretch.input2X) stretch.input1X.set(self.crvInfo.arcLength.get()) stretchClamp = pm.createNode('clamp', name=self.getName('stretchClamp_utl')) stretchClamp.maxR.set(1.0) stretch.outputX.connect(stretchClamp.inputR) # Sine --------------------------------------------- pm.select(None) sineDef = pm.nonLinear(self.sineCrv, type='sine', name=self.getName('sine_def')) sineDef[1].rz.set(-90) sineDef[1].setParent(self.noXForm) host.sine_roll.connect(sineDef[1].ry) sinePosMult = pm.createNode('multDoubleLinear', name=self.getName('sinePosMult_utl')) host.sine_centre.connect(sinePosMult.input1) sinePosMult.input2.set(self.settings['num_joints']) sinePosMult.output.connect(sineDef[1].tx) host.sine_decay.connect(sineDef[0].dropoff) host.sine_amplitude.connect(sineDef[0].amplitude) host.sine_wavelength.connect(sineDef[0].wavelength) host.sine_offset.connect(sineDef[0].offset) sineHighRange = pm.createNode('setRange', name=self.getName('sineHighRange_utl')) sineHighRange.oldMinX.set(0) sineHighRange.oldMaxX.set(1) sineHighRange.minX.set(2) sineHighRange.maxX.set(0) host.sine_centre.connect(sineHighRange.valueX) sineHighRange.outValueX.connect(sineDef[0].highBound) sineLowRange = pm.createNode('setRange', name=self.getName('sineLowRange_utl')) sineLowRange.oldMinX.set(0) sineLowRange.oldMaxX.set(1) sineLowRange.minX.set(0) sineLowRange.maxX.set(-2) host.sine_centre.connect(sineLowRange.valueX) sineLowRange.outValueX.connect(sineDef[0].lowBound) # Joints ------------------------------------------- self.joints = [] for i in range(self.settings['num_joints']): num = str(i + 1).zfill(2) # per joint stretch and grow param = (1.0 / (self.settings['num_joints'] - 1)) * i stretchedParam = pm.createNode( 'multDoubleLinear', name=self.getName('result_%s_stretchedParam_utl' % num)) stretchedParam.input1.set(param) stretchClamp.outputR.connect(stretchedParam.input2) stretchBlend = pm.createNode( 'blendTwoAttr', name=self.getName('result_%s_stretchBlend_utl' % num)) stretchedParam.input1.connect(stretchBlend.input[1]) stretchedParam.output.connect(stretchBlend.input[0]) host.stretch.connect(stretchBlend.attributesBlender) growBlend = pm.createNode('animBlendNodeAdditive', name=self.getName( 'result_%s_growBlend_utl' % num)) stretchBlend.output.connect(growBlend.inputA) host.grow.connect(growBlend.weightA) # twisting and rolling roll = pm.createNode('animBlendNodeAdditiveDA', name=self.getName('result_%s_twist_utl' % num)) host.roll.connect(roll.inputA) host.twist.connect(roll.inputB) growBlend.output.connect(roll.weightB) mp = pm.createNode('motionPath', name=self.getName('result_%s_mp_utl' % num)) self.fkCrv.worldSpace[0].connect(mp.geometryPath) mp.fractionMode.set(1) mp.frontAxis.set(0) mp.upAxis.set(1) mp.follow.set(1) mp.worldUpType.set(3) growBlend.output.connect(mp.uValue) roll.output.connect(mp.frontTwist) mpUp = pm.createNode('motionPath', name=self.getName('result_%s_upMp_utl' % num)) self.fkRailCrv.worldSpace[0].connect(mpUp.geometryPath) mpUp.fractionMode.set(1) growBlend.output.connect(mpUp.uValue) upVec = pm.createNode('plusMinusAverage', name=self.getName('result_%s_upVec_utl' % num)) mpUp.allCoordinates.connect(upVec.input3D[0]) mp.allCoordinates.connect(upVec.input3D[1]) upVec.operation.set(2) upVec.output3D.connect(mp.worldUpVector) # sine wave sineMp = pm.createNode('motionPath', name=self.getName('sine_%s_mp_utl' % num)) self.sineCrv.worldSpace[0].connect(sineMp.geometryPath) sineMp.uValue.set(i) j = pm.createNode('joint', name=self.getName('%s_dfm' % num)) if not i: self.dm[0].outputScale.connect(j.s) j.setParent(self.noXForm) wMtx = pm.createNode('composeMatrix', name=self.getName( 'result_%s_worldMtx_utl' % num)) mp.allCoordinates.connect(wMtx.inputTranslate) mp.rotate.connect(wMtx.inputRotate) localMtx = pm.createNode('multMatrix', name=self.getName( 'result_%s_localMtx_utl' % num)) wMtx.outputMatrix.connect(localMtx.matrixIn[0]) #self.root.worldInverseMatrix[0].connect(localMtx.matrixIn[1]) d = pm.createNode('decomposeMatrix', name=self.getName('result_%s_mtx2Srt_utl' % num)) localMtx.matrixSum.connect(d.inputMatrix) deformedPos = pm.createNode( 'plusMinusAverage', name=self.getName('result_%s_deformedPos_utl' % num)) d.outputTranslate.connect(deformedPos.input3D[0]) sineMp.allCoordinates.yCoordinate.connect( deformedPos.input3D[1].input3Dy) sineMp.allCoordinates.zCoordinate.connect( deformedPos.input3D[1].input3Dz) deformedPos.output3D.connect(j.t) d.outputRotate.connect(j.r) else: j.setParent(self.joints[-1]) wMtx = pm.createNode('composeMatrix', name=self.getName( 'result_%s_worldMtx_utl' % num)) mp.allCoordinates.connect(wMtx.inputTranslate) mp.rotate.connect(wMtx.inputRotate) localMtx = pm.createNode('multMatrix', name=self.getName( 'result_%s_localMtx_utl' % num)) wMtx.outputMatrix.connect(localMtx.matrixIn[0]) self.joints[-1].worldInverseMatrix[0].connect( localMtx.matrixIn[1]) d = pm.createNode('decomposeMatrix', name=self.getName('result_%s_mtx2Srt_utl' % num)) localMtx.matrixSum.connect(d.inputMatrix) deformedPos = pm.createNode( 'plusMinusAverage', name=self.getName('result_%s_deformedPos_utl' % num)) d.outputTranslate.connect(deformedPos.input3D[0]) sineMp.allCoordinates.yCoordinate.connect( deformedPos.input3D[1].input3Dy) sineMp.allCoordinates.zCoordinate.connect( deformedPos.input3D[1].input3Dz) deformedPos.output3D.connect(j.t) d.outputRotate.connect(j.r) j.segmentScaleCompensate.set(0) j.jo.set(0, 0, 0) self.joints.append(j)
from PySide import QtGui import pymel.core as pm from pprint import pprint import re headSquash = pm.PyNode('head_squash_Handle') bendHeadRL = pm.PyNode('bend_headRL_Handle') bendHeadFB = pm.PyNode('bend_headFB_Handle') headGrp = ['body_grp','m_eye_geo_group', 'eye_patch_grp' ] pm.nonLinear(headSquash, e = True, g = headGrp ) pm.nonLinear(bendHeadRL, e = True, g = headGrp ) pm.nonLinear(bendHeadFB, e = True, g = headGrp ) helmetSquash = pm.PyNode('helmet_squash_Handle') bendHelmetRL = pm.PyNode('bend_helmetFB_Handle') bendHelmetFB = pm.PyNode('bend_helmetRL_Handle') helmetGrp = ['helmet_grp'] pm.nonLinear(helmetSquash, e = True, g = helmetGrp ) pm.nonLinear(bendHelmetRL, e = True, g = helmetGrp ) pm.nonLinear(bendHelmetFB, e = True, g = helmetGrp )
def doRig(self): if pm.objExists('head_contrained'): constrained_grp = 'head_contrained' else: constrained_grp = pm.group(n='head_contrained', em=True) if pm.objExists(self.name + "Ctrl_grp"): pm.delete(self.name + "Ctrl_grp") if pm.objExists(self.name + 'Sys_grp'): pm.delete(self.name + 'Sys_grp') deformLength = self.length.distance.get() proxy = pm.polyCube(n="def_proxy", ch=False)[0] matrix = pm.xform (self.midGuide, m=True, ws=True, q=True) pm.xform(proxy, m=matrix, ws=True) proxy.scaleY.set(deformLength) pm.select(proxy) squash = pm.nonLinear(type='squash') pm.nonLinear(squash[0], e=True, lowBound=0, highBound=1, startSmoothness=0, endSmoothness=0) pm.select(proxy) bendA = pm.nonLinear(type='bend') pm.nonLinear(bendA[0],e=True, lowBound=0, highBound=1, curvature=0) pm.select(proxy) bendB = pm.nonLinear(type='bend') pm.nonLinear(bendB[0], e=True, lowBound=0, highBound=1, curvature=0) matrix = pm.xform(self.baseGuide, m=True, ws=True, q=True) deformers = pm.group(em=True, n=self.name + 'Sys_grp') pm.xform(deformers, m=matrix, ws=True) pm.parent(squash, bendA, bendB, proxy, deformers) pm.setAttr(deformers + ".visibility", 0) pm.xform(squash[1], m=matrix, ws=True) pm.xform(bendA[1], m=matrix, ws=True) pm.xform(bendB[1], m=matrix, ws=True) pm.xform (bendB[1], ro=(0, 90 ,0), r=True) pm.setAttr(bendB[0] + ".highBound", deformLength) pm.setAttr(bendA[0] + ".highBound", deformLength) pm.setAttr(squash[0] + ".highBound", deformLength) ## Criar controle squashCtrl = pm.curve(d=1, p=[(-1, 0, -2), (1, 0, -2), (1, 0, 2), (3, 0, 2), (0, 0, 5), (-3, 0, 2), (-1, 0, 2), (-1, 0, -2)], k=[0, 1, 2, 3, 4, 5, 6, 7], n="squash_ctrl") pm.xform(squashCtrl, cp=True) squashCtrl.rotateX.set(90) squashCtrl.scale.set((0.5, 0.5, 0.5)) pm.makeIdentity(squashCtrl, apply=True, t=1, r=1, s=1, n=0, pn=1) squashGrp = pm.group(squashCtrl, n=self.name+"Ctrl_grp") pm.parent(squashGrp, constrained_grp) matrix = pm.xform(self.ctrlGuide, m=True, ws=True, q=True) pm.xform(squashGrp, m=matrix, ws=True) # Conectar controle mult = pm.shadingNode('multiplyDivide', asUtility=True) pm.connectAttr((squashCtrl) + '.translateY', mult + '.input1Y') pm.connectAttr((squashCtrl) + '.translateX', mult + '.input1X') pm.connectAttr((squashCtrl) + '.translateZ', mult + '.input1Z') pm.setAttr(mult + '.input2X', 5) pm.setAttr(mult + '.input2Y', .2) pm.setAttr(mult + '.input2Z', -5) pm.connectAttr(mult + '.outputY', squash[0] + '.factor') pm.connectAttr(mult + '.outputX', bendA[0] + '.curvature') pm.connectAttr(mult + '.outputZ', bendB[0] + '.curvature') maxExpandPos = self.midPos.distance.get()/deformLength pm.setAttr(squash[0]+'.maxExpandPos', maxExpandPos) self.guideMoveall.visibility.set(0)
def create_ribbon(numJoints=10, prefix='testRibbon', numSpans=5, startObj=None, endObj=None): rigGrp = pm.group(empty=True, name='%s_rig_grp' %prefix) ctrlGrp = pm.group(empty=True, name="%s_ctrl_grp" %prefix) proxyGrp = pm.group(empty=True, name="%s_proxy_grp" %prefix) ctrlGrp.overrideDisplayType.set(1) #template proxyGrp.visibility >> ctrlGrp.overrideEnabled #=========================================================================== # proxy #=========================================================================== proxy_start = pm.spaceLocator(name='%s_root_start' %prefix) pm.parent( proxy_start.add_parent_group(suffix='const'), proxyGrp) proxy_end = pm.spaceLocator(name='%s_root_end' %prefix) proxy_end.tx.set(1) pm.parent( proxy_end.add_parent_group(suffix='const'), proxyGrp) #=========================================================================== # proxy #=========================================================================== rootCtrl = pm.spaceLocator(name='%s_root_ctrl' %prefix) pm.parent(pm.parentConstraint(proxy_start, rootCtrl, mo=False), proxyGrp) pm.parent(rootCtrl, ctrlGrp) proxy_up = pm.spaceLocator(name='%s_root_up' %prefix) proxy_up.ty.set(1) pm.parent( proxy_up.add_parent_group(suffix='const'), proxyGrp) proxy_mid = pm.spaceLocator(name='%s_root_mid' %prefix) proxy_mid.tx.set(1) proxy_mid_const = proxy_mid.add_parent_group(suffix='const') pm.parent( proxy_mid_const, proxyGrp) pm.pointConstraint(proxy_start, proxy_end, proxy_mid_const, mo=False) pm.aimConstraint(proxy_end, proxy_start, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name()) pm.aimConstraint(proxy_start, proxy_end, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name()) pm.parentConstraint(rootCtrl, rigGrp, mo=False) #=========================================================================== # ribbon plane #=========================================================================== ribbonGrp = pm.group(empty=True, name="%s_ribbon_grp" %prefix) pm.parent(ribbonGrp, rigGrp) follicleGrp = pm.group(empty=True, name="%s_follicle_grp" %prefix) pm.parent(follicleGrp, rigGrp) follicleGrp.inheritsTransform.set(0) follicleGrp.overrideDisplayType.set(2) #reference proxyGrp.visibility >> follicleGrp.overrideEnabled ribbonName = "%s_ribbon" %prefix ribbon = pm.nurbsPlane(ax=[0,1,0], w=1, lr=0.05, d=3, u=10, v=1, ch=0, name=ribbonName)[0] ribbon.translateX.set(0.5) ribbon.rotateX.set(90) pm.makeIdentity(ribbon, apply=True, t=1 ,r=1 ,s=1, n=0 ,pn=1) ribbon.scalePivot.set(0,0,0) ribbon.rotatePivot.set(0,0,0) pm.parent(ribbon, ribbonGrp) ribbonGrp.visibility.set(0) #proxy_start.rotateX >> ribbon.rotateX #=========================================================================== # ribbon follicles / joints #=========================================================================== joints = [] proxyCubes = [] spacing = (1.0/(numJoints-1)) for i in range(numJoints): uPos = i * spacing jointName = "%s_%d" %(prefix, i+1) fol = create_follicle(ribbon, uPos, 0.5) fol_trans = fol.getParent() pm.select(clear=True) joint = pm.joint(name=jointName) #======================================================================= cube = pm.polyCube(w=spacing, h=spacing, d=spacing, ch=False)[0] pm.parentConstraint(joint, cube) pm.parent(cube, joint) # pm.parent(cube, proxyGrp) proxyCubes.append(cube) cube.overrideEnabled.set(1) cube.overrideDisplayType.set(2) #reference #======================================================================= pm.parent(joint, fol_trans, r=True) pm.parent(fol_trans, follicleGrp) joints.append(joint) #=========================================================================== # ribbon wires #=========================================================================== wireGrp = pm.group(empty=True, name="%s_wire_grp" %prefix) pm.parent(wireGrp, rigGrp) wireCtrlGrp = pm.group(empty=True, name='%s_wire_ctrl_grp' %prefix) pm.parent(wireCtrlGrp, rootCtrl) wireCtrlGrp.inheritsTransform.set(0) wireName = '%s_wire' %prefix wireCurve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name=wireName) mel.eval("rebuildCurve -ch 0 -rpo 1 -rt 0 -end 1 -kr 0 -kcp 0 -kep 1 -kt 0 -s %d -d 2 %s" %(numSpans, wireCurve.name())) wire2, wireCurve, wireBaseCurve = wire_deformer( wireCurve, ribbon) pm.parent(wireCurve, wireBaseCurve, wireGrp) #pm.reorderDeformers(wire1, wire2, ribbon) #=========================================================================== # ribbon curve/ctrls #=========================================================================== curve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name="%s_curve"%prefix) pm.parent(curve, ribbonGrp) #wire1, curve, baseCurve = wire_deformer( curve, wireCurve) ctrls=[] for cv in curve.cv: clusterName = '%s_curve%d_cluster' %(prefix, cv.index()) ctrlName = "%s_curve%d_ctrl" %(prefix, cv.index()) cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName) clusterHandle.visibility.set(0) ctrl = pm.spaceLocator(name=ctrlName) pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False)) pm.parentConstraint(ctrl, clusterHandle) ctrls.append(ctrl) pm.parent(clusterHandle, ribbonGrp) startCtrl = ctrls[0] midCtrl = ctrls[1] endCtrl = ctrls[-1] startCtrlName = "%s_start_ctrl" %prefix endCtrlName = "%s_end_ctrl" %prefix startCtrl.rename("%s_start_ctrl" %prefix) startConst = startCtrl.add_parent_group(suffix='const') pm.parent(pm.parentConstraint(proxy_start, startConst, mo=False), proxyGrp) endCtrl.rename("%s_end_ctrl" %prefix) endConst = endCtrl.add_parent_group(suffix='const') pm.parent(pm.parentConstraint(proxy_end, endConst, mo=False), proxyGrp) midCtrl.rename("%s_mid_ctrl" %prefix) midConst = midCtrl.add_parent_group(suffix='const') pm.parent(pm.parentConstraint(proxy_mid, midConst, mo=False), proxyGrp) startCtrl.getShape().localPositionX.set(-1) endCtrl.getShape().localPositionX.set(1) pm.parent(startConst, endConst, midConst, rootCtrl) #=========================================================================== # ribbon wire cluster #=========================================================================== for cv in wireCurve.cv: #cluster / ctrl clusterName = '%s_wire%d_cluster' %(prefix, cv.index()) ctrlName = "%s_wire%d_ctrl" %(prefix, cv.index()) cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName) ctrl = pm.spaceLocator(name=ctrlName) pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False)) pm.parentConstraint(ctrl, clusterHandle) pm.scaleConstraint(ctrl, clusterHandle) #ctrl.t >> clusterHandle.t #ctrl.r >> clusterHandle.r #ctrl.s >> clusterHandle.s ctrls.append(ctrl) pm.parent(clusterHandle, wireGrp) #revit revit = pm.spaceLocator(name="%s_revit" %ctrl.name()) revit.getShape().localScale.set(0,0,0) pm.delete(pm.parentConstraint(ctrl, revit, mo=False)) pm.parent(ctrl, revit) revit_locator_to_curve(revit, curve) rootCtrl.r >> revit.r pm.parent(revit, wireCtrlGrp) wireGrp.visibility.set(0) #=========================================================================== # twist #=========================================================================== twistGrp = pm.group(empty=True, name="%s_twist_grp" %prefix) pm.parent(twistGrp, rigGrp) startTwist = pm.group(empty=True, name="%s_start_twist" %prefix) startTwistAim = startTwist.add_parent_group(suffix='aim') pm.pointConstraint(startCtrl, startTwistAim, mo=False) endTwist = pm.group(empty=True, name="%s_end_twist" %prefix) endTwistAim = endTwist.add_parent_group(suffix='aim') pm.pointConstraint(endCtrl, endTwistAim, mo=False) startTwistUp = pm.spaceLocator(name="%s_start_twistUp" %prefix) pm.delete(pm.parentConstraint(startCtrl, startTwistUp, mo=False)) startTwistUp.ty.set(1) pm.parentConstraint(startCtrl, startTwistUp, mo=True) endTwistUp = pm.spaceLocator(name="%s_end_twistUp" %prefix) pm.parentConstraint(endCtrl, endTwistUp, mo=False) endTwistUp.ty.set(1) const = pm.parentConstraint(endCtrl, endTwistUp, mo=True) pm.aimConstraint(endTwistAim, startTwistAim, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=startCtrl.name()) pm.aimConstraint(startTwistAim, endTwistAim, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=endCtrl.name()) #pm.aimConstraint(endTwist, startTwist, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=startTwistUp.name()) #pm.aimConstraint(startTwist, endTwist, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=endTwistUp.name()) twist, twistHdl = pm.nonLinear(ribbon , type='twist', foc=True, name='%s_twist'%prefix) twistHdl.rotateZ.set(90) startTwistAim.rx >> twist.endAngle endTwistAim.rx >> twist.startAngle #startTwist.rx >> twist.endAngle #endTwist.rx >> twist.startAngle pm.parent(startTwistUp, endTwistUp, twistHdl, startTwistAim, endTwistAim, twistGrp) twistGrp.visibility.set(0) #=========================================================================== # stretch and squash #=========================================================================== stretchGrp = pm.group(empty=True, name="%s_stretch_grp" %prefix) stretchGrp.addAttr('baseDistance', at='double') pm.parent(stretchGrp, rigGrp) stretchGrp.inheritsTransform.set(0) stretchPlane = pm.nurbsPlane(ax=[0,1,0], ch=False, w=2, lr=1, d=3, u=2, v=2, name='%s_stretch_plane'%prefix) squash, squashHdl = pm.nonLinear(stretchPlane, type='squash', foc=True, name="%s_squash"%prefix) squashHdl.rotateZ.set(90) for i in range(numJoints): spacing = i * (1.0/(numJoints-1)) pointOnSurface = pm.createNode('pointOnSurfaceInfo') stretchPlane[0].getShape().worldSpace[0] >> pointOnSurface.inputSurface pointOnSurface.parameterU.set(spacing) pointOnSurface.positionZ >> joints[i].sz pointOnSurface.positionZ >> joints[i].sy baseDistance = pm.createNode('distanceBetween', name="%s_base_distance" %prefix) proxy_start.getShape().worldPosition[0] >> baseDistance.point1 proxy_end.getShape().worldPosition[0] >> baseDistance.point2 stretchDistance = pm.createNode('distanceBetween', name="%s_stretch_distance" %prefix) stretchDistanceStart = pm.spaceLocator(name="%s_stretch_distance_start" %prefix) stretchDistanceStart.localScale.set(0,0,0) pm.parentConstraint(startCtrl, stretchDistanceStart, mo=False) stretchDistanceEnd = pm.spaceLocator(name="%s_stretch_distance_end" %prefix) stretchDistanceEnd.localScale.set(0,0,0) pm.parentConstraint(endCtrl, stretchDistanceEnd, mo=False) stretchDistanceStart.getShape().worldPosition[0] >> stretchDistance.point1 stretchDistanceEnd.getShape().worldPosition[0] >> stretchDistance.point2 strechFactor_md = pm.createNode('multiplyDivide', name='%s_stretch_distance_md' %prefix) strechFactor_md.operation.set(2) #divide baseDistance.distance >> stretchGrp.baseDistance stretchGrp.baseDistance >> strechFactor_md.input2X stretchDistance.distance >> strechFactor_md.input1X strechFactor_remap = pm.createNode('remapValue', name="%s_stretch_factor_remap" %prefix) strechFactor_md.outputX >> strechFactor_remap.inputValue strechFactor_remap.inputMin.set(0.5) strechFactor_remap.inputMax.set(1.5) strechFactor_remap.outputMin.set(-1) strechFactor_remap.outputMax.set(1) strechFactor_remap.outValue >> squash.factor pm.parent(stretchDistanceStart, stretchDistanceEnd, stretchPlane, squashHdl, stretchGrp) stretchGrp.visibility.set(0) #=========================================================================== for cube in proxyCubes: stretchGrp.baseDistance >> cube.sx stretchGrp.baseDistance >> cube.sy stretchGrp.baseDistance >> cube.sz stretchGrp.baseDistance >> ribbon.sz #=========================================================================== #=========================================================================== # Positioning #=========================================================================== if startObj and endObj: pm.delete(pm.parentConstraint(startObj, proxy_start, mo=False)) pm.delete(pm.parentConstraint(endObj, proxy_end, mo=False)) pm.delete(pm.parentConstraint(startObj, proxy_up, mo=False)) proxy_up.ty.set(proxy_up.ty.get() + 1)
def doRig(self): anchorList = [] cntrlList = [] locList = [] offCtrlLoc=[] offAuxLoc = [] dummyCrv = self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv' pm.hide(pm.polyCube(n=dummyCrv)) if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']): pm.delete(self.ribbonDict['moveallSetup']['nameTempl']) if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']): pm.delete(self.ribbonDict['noMoveSetup']['nameTempl']) ###Estrutura que nao deve ter transformacao noMoveSpace = pm.group(empty=True, n=self.ribbonDict['noMoveSetup']['nameTempl']) if not pm.objExists('NOMOVE'): pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE') else: pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE') pm.parent(self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv', noMoveSpace) noMoveSpace.visibility.set(0) noMoveSpace.translate.set(self.size * -0.5, 0, 0) noMoveBend1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) noMoveBend2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) noMoveCrvJnt = pm.curve(bezier=True, d=3, p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0), (self.size * -0.496, 0, 0), (self.size * -0.495, 0, 0), (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0), (0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0), (self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0), (self.size * 0.499, 0, 0), (self.size * 0.50, 0, 0)], k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10]) noMoveCrvTweak1 = pm.curve(d=2, p=[(self.size * -0.5, 0, 0), (self.size * -0.25, 0, 0), (self.size * 0, 0, 0)], k=[0, 0, 1, 1]) noMoveCrvTweak2 = pm.curve(d=2, p=[(self.size * 0.0, 0, 0), (self.size * 0.25, 0, 0), (self.size * 0.50, 0, 0)], k=[0, 0, 1, 1]) # Deformers das superficies noMove twist1 = pm.nonLinear(noMoveBend1[0], type='twist') # twist das superficies noMove twist2 = pm.nonLinear(noMoveBend2[0], type='twist') twist1[1].rotateZ.set(90) twist2[1].rotateZ.set(90) wireTweak1 = pm.wire(noMoveBend1[0], w=noMoveCrvTweak1, dds=[(0, 50)]) wireTweak2 = pm.wire(noMoveBend2[0], w=noMoveCrvTweak2, dds=[(0, 50)]) wireDef = pm.wire(noMoveBend1[0], noMoveBend2[0], w=noMoveCrvJnt, dds=[(0, 50)]) # Wire das superficies noMove wireDef[0].rotation.set(1) # seta wire controlando rotacao baseWire = [x for x in wireDef[0].connections() if 'BaseWire' in x.name()] baseWireTweak1 = [x for x in wireTweak1[0].connections() if 'BaseWire' in x.name()] baseWireTweak2 = [x for x in wireTweak2[0].connections() if 'BaseWire' in x.name()] pm.group(baseWire, baseWireTweak1, baseWireTweak2, noMoveCrvJnt, noMoveCrvTweak1, noMoveCrvTweak2, noMoveBend1[0], noMoveBend2[0], p=noMoveSpace, n=self.name + 'Deforms') pm.parent(twist1[1], twist2[1], noMoveSpace) ###Estrutura que pode ser movida cntrlsSpace = pm.group(empty=True, n=self.ribbonDict['moveallSetup']['nameTempl']) cntrlsSpace.translate.set(self.size * -0.5, 0, 0) bendSurf1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) bendSurf2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) # blendShape transferindo as deformaacoes para a superficie move blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0]) blend2 = pm.blendShape(noMoveBend2[0], bendSurf2[0]) pm.blendShape(blend1, e=True, w=[(0, 1)]) pm.blendShape(blend2, e=True, w=[(0, 1)]) pm.parent(bendSurf1[0], bendSurf2[0], cntrlsSpace) ##Cntrls tweak1Cls = pm.cluster(noMoveCrvTweak1.name()+'.cv[1]') tweak2Cls = pm.cluster(noMoveCrvTweak2.name() + '.cv[1]') displaySetup = self.ribbonDict['ctrlTweakSetup'].copy() cntrlName = displaySetup['nameTempl'] + '1' cntrlTweak1 = controlTools.cntrlCrv(name=cntrlName, obj=tweak1Cls[1], connType='connection', align='pivot', offsets=1, **displaySetup) cntrlName = displaySetup['nameTempl'] + '2' cntrlTweak2 = controlTools.cntrlCrv(name=cntrlName, obj=tweak2Cls[1], connType='connection', align='pivot', offsets=1, **displaySetup) controlTools.addMultiply([cntrlTweak1.getParent(), cntrlTweak2.getParent()]) tweakFoll1 = self.attachObj(obj=cntrlTweak1.getParent(3), mesh=bendSurf1[0], u=0.5, v=0.5, mode=4) tweakFoll2 = self.attachObj(obj=cntrlTweak2.getParent(3), mesh=bendSurf2[0], u=0.5, v=0.5, mode=4) tweakGrp = pm.group(tweak1Cls[1], tweak2Cls[1], n=self.name+'TweakCls_grp') pm.parent(tweakGrp, noMoveSpace) pm.parent(cntrlTweak1.getParent(3), cntrlTweak2.getParent(3), cntrlsSpace) for i in range(0, 7): anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) + ']') pm.cluster(anchor[1], e=True, g=dummyCrv) clsHandle = anchor[1] anchorGrp = pm.group(em=True, n=self.name+'clusterGrp' + str(i)) anchorDrn = pm.group(em=True, n=self.name+'clusterDrn' + str(i), p=anchorGrp) pos = pm.xform(anchor[1], q=True, ws=True, rp=True) pm.xform(anchorGrp, t=pos, ws=True) pm.parent(anchor[1], anchorDrn) anchorList.append(anchor[1]) if i == 0 or i == 6: displaySetup = self.ribbonDict['cntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) elif i == 3: displaySetup = self.ribbonDict['midCntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) else: displaySetup = self.ribbonDict['cntrlTangSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) offCtrlLoc.append(pm.spaceLocator(n=cntrlName+'off_loc')) offCtrlLoc[-1].localScale.set(0.2, 0.2, 0.2) pm.parent(offCtrlLoc[-1], cntrl, r=True) if i in [1, 2, 4, 5]: offCtrlLoc[-1].getShape().visibility.set(False) # Nao pode fazer conexao na criacao do controle, pois tera conexao direta pm.xform(cntrl.getParent(), t=pos, ws=True) # estrutura de buffers para conexao direta auxLocGrp = pm.group(em=True, n=self.name + 'Aux_grp') auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + str(i)+ 'Aux_loc') pm.xform(auxLocGrp, t=pos, ws=True) loc = pm.PyNode(auxLoc) if i==0 or i==3 or i==6: tmpOffAuxLoc = pm.group(em=True, n=self.name + str(i) + 'AuxOff_loc') offAuxLoc.append(tmpOffAuxLoc) pm.parent(tmpOffAuxLoc, auxLoc, r=True) offCtrlLoc[-1].translate >> offAuxLoc[-1].translate offCtrlLoc[-1].rotate >> offAuxLoc[-1].rotate if i == 1 or i == 4: pm.xform(anchorGrp, s=(-1, 1, 1), r=True) pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True) pm.xform(loc.getParent(), s=(-1, 1, 1), r=True) # Conexoes dos buffers cm os clusters e com os controles pm.parentConstraint(cntrl, loc, mo=True) loc.translate >> anchorDrn.translate loc.rotate >> anchorDrn.rotate cntrlList.append(cntrl) locList.append(loc) # workaround do flip do inicio do wire(adicao de mais pontos) startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]') endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]') pm.cluster(startCls[1], e=True, g=dummyCrv) pm.cluster(endCls[1], e=True, g=dummyCrv) pm.parent(startCls[1], anchorList[0]) pm.parent(endCls[1], anchorList[6]) cntrlsSpace.addAttr('midCtrlViz', at='double', dv=1, max=1, min=0, k=True, h=False) cntrlsSpace.addAttr('bezierCtrlViz', at='double', dv=1,max=1, min=0, k=True, h=False) cntrlsSpace.addAttr('bendExtraCtrlViz', at='double',max=1, min=0, dv=1, k=True, h=False) cntrlsSpace.addAttr('extraCtrlsVis', at='double', dv=0,max=1, min=0, k=True, h=False) cntrlList[0].addAttr('twist', at='double', dv=0, k=True) cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[3].addAttr('twist', at='double', dv=0, k=True) cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True) cntrlList[6].addAttr('twist', at='double', dv=0, k=True) cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[0].twist >> twist1[0].endAngle cntrlList[3].twist >> twist1[0].startAngle cntrlList[3].twist >> twist2[0].endAngle cntrlList[6].twist >> twist2[0].startAngle # cria sistema do tweak pra compensar twist da ribbon tweak1Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi') tweak1Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi') tweak1Add = pm.createNode('addDoubleLinear', name='tweak1Add') tweak2Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi') tweak2Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi') tweak2Add = pm.createNode('addDoubleLinear', name='tweak1Add') cntrlList[0].twist >> tweak1Twist1Multi.input1 tweak1Twist1Multi.input2.set(-0.5) cntrlList[3].twist >> tweak1Twist2Multi.input1 tweak1Twist2Multi.input2.set (-0.5) tweak1Twist1Multi.output >> tweak1Add.input1 tweak1Twist2Multi.output >> tweak1Add.input2 tweak1Add.output >> cntrlTweak1.getParent(2).rotate.rotateX cntrlList[6].twist >> tweak2Twist1Multi.input1 tweak2Twist1Multi.input2.set(-0.5) cntrlList[3].twist >> tweak2Twist2Multi.input1 tweak2Twist2Multi.input2.set(-0.5) tweak2Twist1Multi.output >> tweak2Add.input1 tweak2Twist2Multi.output >> tweak2Add.input2 tweak2Add.output >> cntrlTweak2.getParent(2).rotate.rotateX # hierarquia pm.parent(anchorList[1].getParent(2), anchorList[0]) pm.parent(anchorList[5].getParent(2), anchorList[6]) pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2), anchorList[3]) pm.parent(cntrlList[1].getParent(), offCtrlLoc[0]) pm.parent(cntrlList[5].getParent(), offCtrlLoc[6]) pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(), offCtrlLoc[3]) pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(), cntrlList[6].getParent(), cntrlsSpace) pm.parent(locList[1].getParent(), offAuxLoc[0]) pm.parent(locList[5].getParent(), offAuxLoc[2]) pm.parent(locList[2].getParent(), locList[4].getParent(), offAuxLoc[1]) pm.parent(locList[3].getParent(), locList[0].getParent(), locList[6].getParent(), cntrlsSpace) pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2), anchorList[6].getParent(2), noMoveSpace) for i, j in zip([1, 2, 4, 5], [0, 3, 3, 6]): crv = pm.curve(d=1, p=[(1, 0, 0), (-1, 0, 0)], k=[0, 1]) crv.inheritsTransform.set(False) crv.template.set(True) offCtrlLoc[i].worldPosition[0] >> crv.getShape().controlPoints[0] offCtrlLoc[j].worldPosition[0] >> crv.getShape().controlPoints[1] pm.parent(crv, offCtrlLoc[i], r=True) # Skin joints do ribbon skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts') follGrp = pm.group(em=True, n=self.name + 'Foll_grp') pm.parent(tweakFoll1, tweakFoll2, follGrp) # cria ramps para controlar o perfil de squash e stretch ramp1 = pm.createNode('ramp', n=self.name+'SquashRamp1') ramp1.attr('type').set(1) ramp2 = pm.createNode('ramp', n=self.name+'SquashRamp2') ramp2.attr('type').set(1) expre1 = "float $dummy = " + ramp1.name() + ".outAlpha;float $output[];float $color[];" expre2 = "float $dummy = " + ramp2.name() + ".outAlpha;float $output[];float $color[];" extraCntrlsGrp = pm.group(em=True, r=True, p=cntrlsSpace, n=self.name + 'ExtraCntrls') # loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon. # cria tmb node tree pro squash/stretch # e controles extras vIncrement = float((1.0 - (self.offsetStart + self.offsetEnd)) / ((self.numJnts - 2) / 2.0)) for i in range(1, (self.numJnts / 2) + 1): # cria estrutura pra superficie 1 pm.select(cl=True) jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'A' + str(i) + self.jntSulfix jnt1 = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(jnt1) displaySetup = self.ribbonDict['cntrlExtraSetup'].copy() cntrlName = displaySetup['nameTempl'] + 'A' + str(i) cntrl1 = controlTools.cntrlCrv(name=cntrlName, obj=jnt1, connType='constraint', **displaySetup) # node tree blend1A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1A') blend1B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1B') gammaCorr1 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma1') cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX blend1A.input[0].set(1) gammaCorr1.outValueX >> blend1A.input[1] blend1B.input[0].set(1) blend1A.output >> blend1B.input[1] cntrlList[3].attr ('autoVolume') >> blend1B.attributesBlender blend1B.output >> cntrl1.getParent().scaleY blend1B.output >> cntrl1.getParent().scaleZ # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str( self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name() + " `;$output[" + str( i) + "] = $color[0];" + blend1A.name() + ".attributesBlender=$output[" + str(i) + "];" # cria estrutura pra superficie 2 pm.select(cl=True) jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'B' + str(i) + self.jntSulfix jnt2 = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(jnt2) displaySetup = self.ribbonDict['cntrlExtraSetup'].copy() cntrlName = displaySetup['nameTempl'] + 'B' + str(i) cntrl2 = controlTools.cntrlCrv(name=cntrlName, connType='constraint', obj=jnt2, **displaySetup) # node tree blend2A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2A') blend2B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2B') gammaCorr2 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma2') cntrlList[6].attr('autoVolumStregth') >> gammaCorr2.gammaX cntrlList[6].attr('stretchDist') >> gammaCorr2.value.valueX blend2A.input[0].set(1) gammaCorr2.outValueX >> blend2A.input[1] blend2B.input[0].set(1) blend2A.output >> blend2B.input[1] cntrlList[3].attr('autoVolume') >> blend2B.attributesBlender blend2B.output >> cntrl2.getParent().scaleY blend2B.output >> cntrl2.getParent().scaleZ # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch expre2 = expre2 + "$color = `colorAtPoint -o RGB -u " + str( self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp2.name() + " `;$output[" + str( i) + "] = $color[0];" + blend2A.name() + ".attributesBlender=$output[" + str(i) + "];" # prende joints nas supeficies com follicules foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4) foll2 = self.attachObj(cntrl2.getParent(), bendSurf2[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4) pm.parent(cntrl1.getParent(), cntrl2.getParent(), extraCntrlsGrp) pm.parent(jnt1, jnt2, skinJntsGrp) pm.parent(foll1, foll2, follGrp) pm.select (cl=True) jntName = self.ribbonDict['jntSetup']['nameTempl'] +'Elbow' + self.jntSulfix elbowJnt = pm.joint(p=(0, 0, 0), n=jntName) pm.parent(elbowJnt, skinJntsGrp) elbowAuxFoll1 = self.createFoll(bendSurf1[0], 0.999, 0.5) elbowAuxFoll2 = self.createFoll(bendSurf2[0], 0.001, 0.5) pm.parent(elbowAuxFoll1, elbowAuxFoll2, follGrp) orientConstraint = pm.PyNode(pm.orientConstraint(elbowAuxFoll1, elbowAuxFoll2, elbowJnt, mo=False)) orientConstraint.interpType.set(2) pm.pointConstraint(cntrlList[3], elbowJnt, mo=False) # seta expressoes para so serem avaliadas por demanda pm.expression(s=expre1, ae=False, n=self.name+'Expression1') pm.expression(s=expre2, ae=False, n=self.name+'Expression2') pm.parent(skinJntsGrp, cntrlsSpace) pm.parent(follGrp, noMoveSpace) # hideCntrls pm.toggle(bendSurf1[0], bendSurf2[0], g=True) bendSurf1[0].visibility.set(0) bendSurf2[0].visibility.set (0) # skinJntsGrp.visibility.set(0) cntrlsSpace.extraCtrlsVis >> extraCntrlsGrp.visibility cntrlsSpace.bezierCtrlViz >> cntrlList[0].getParent().visibility cntrlsSpace.midCtrlViz >> cntrlList[3].getParent().visibility cntrlsSpace.bezierCtrlViz >> cntrlList[4].getParent().visibility cntrlsSpace.bezierCtrlViz >> cntrlList[2].getParent().visibility cntrlsSpace.bezierCtrlViz >> cntrlList[6].getParent().visibility cntrlsSpace.bendExtraCtrlViz >> cntrlTweak1.getParent().visibility cntrlsSpace.bendExtraCtrlViz >> cntrlTweak2.getParent().visibility # povoa ribbon Dict self.ribbonDict['name'] = 'bezierRibbon' self.ribbonDict['ribbonMoveAll'] = cntrlsSpace for i in range(0, 7): self.ribbonDict['cntrl' + str(i)] = cntrlList[i]
def paperbloc_gen(sel=None, w=21.0, d=29.7, h=2, num_sheets=10, max_xz=0.5, max_rot=10.0, name='paperbloc'): sel = paperbloc_base(w, d, h, name) if not sel: # Get Current selection sel = pmc.ls(sl=True) elif not isinstance(sel, list): sel = [sel] if len(sel) != 2: raise ValueError( 'Select Two Objects please, the fill paper and the paper bloc.') sSel = sel bloc_paper = sel[-1] sel = sel[0] print(bloc_paper) # check if the name already is in the scene i = 0 num = 1 while i < num: chk = pmc.ls(name + '_' + str(i)) if chk: num += 1 i += 1 if i == num: num -= 1 name_grp = name + '_grp_' + str(num) name_fill = name + '_fill_' + str(num) name = name + '_' + str(num) bloc_paper = pmc.duplicate(bloc_paper, n=name) fill_sheets = [bloc_paper[0]] #raise ValueError('STOP DOGGIE') for i in range(num_sheets): r_seed_x = random() * max_xz r_seed_y = random() * h r_seed_z = random() * max_xz r_seed_rot = random() * max_rot coin = coin_toss() if coin == 1: r_seed_rot = -r_seed_rot coin = coin_toss() if coin_toss == 1: r_seed_z = -r_seed_z coin = coin_toss() if coin_toss == 1: r_seed_x = -r_seed_x base_y = pmc.getAttr(sel.translateY) y_val = r_seed_y + base_y n_paper = pmc.duplicate(sel, n=name_fill) n_paper = n_paper[0] coin = coin_toss() if coin == 1: r_pivotx = random() * 10.0 r_pivotz = random() * 10.0 coin = coin_toss() if coin == 1: r_pivotx = -r_pivotx coin = coin_toss() if coin == 1: r_pivotz = -r_pivotz pmc.move(n_paper.rotatePivot, r_pivotx, 0, r_pivotz) pmc.setAttr(n_paper.ty, y_val) pmc.setAttr(n_paper.tx, r_seed_x) pmc.setAttr(n_paper.tz, r_seed_z) pmc.setAttr(n_paper.ry, r_seed_rot) fill_sheets.append(n_paper) print('---------feuilles placees -----------') print(fill_sheets) bender = pmc.nonLinear(fill_sheets, type='bend') print('bend creation') pmc.rename(bender[0], name + '__bend') pmc.rename(bender[-1], name + '__bendHandle') print('---------bend done -----------') pmc.setAttr(bender[-1].rotateZ, 90) fill_sheets.append(bender[0]) fill_sheets.append(bender[-1]) grp = pmc.group(em=True, n=name_grp) pmc.setAttr(grp.ty, base_y) pmc.parent(fill_sheets, grp) ar.zero_out(mc.ls(str(bender[-1]))) pmc.addAttr(grp, ln='bend_me', at='float', k=True) pmc.addAttr(grp, ln='bend_shift', at='float', k=True) pmc.addAttr(grp, ln='bend_min', at='float', min=-10, dv=-1, max=0, k=True) pmc.addAttr(grp, ln='bend_max', at='float', min=0, dv=1, max=10, k=True) pmc.addAttr(grp, ln='pos_bendx', at='float', k=True) pmc.addAttr(grp, ln='pos_bendz', at='float', k=True) pmc.connectAttr(grp.bend_me, bender[0].curvature) pmc.connectAttr(grp.bend_shift, bender[-1].rx) pmc.connectAttr(grp.bend_min, bender[0].lowBound) pmc.connectAttr(grp.bend_max, bender[0].highBound) pmc.connectAttr(grp.pos_bendx, bender[-1].ty) pmc.connectAttr(grp.pos_bendz, bender[-1].tz) pmc.delete(sSel) pmc.select(pmc.ls(grp)) return grp
def create_surface(self, name='Surface', epsilon=0.001, default_scale=1.0): """ Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide a surface for the influence to slide on. :param name: The suffix of the surface name to create. :return: A pymel.nodetypes.Transform instance of the created surface. """ nomenclature = self.get_nomenclature_rig().copy() nomenclature.add_tokens(name) root = pymel.createNode('transform') pymel.addAttr(root, longName='bendUpp', k=True) pymel.addAttr(root, longName='bendLow', k=True) pymel.addAttr(root, longName='bendSide', k=True) # Create Guide plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4) # Create Bends bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform, type='bend') bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform, type='bend') bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform, type='bend') plane_transform.r.set(0, -90, 0) bend_side_handle.r.set(90, 90, 0) bend_upp_handle.r.set(180, 90, 0) bend_low_handle.r.set(180, 90, 0) bend_upp_deformer.highBound.set(0) # create pymel warning bend_low_deformer.lowBound.set(0) # create pymel warning plane_transform.setParent(root) bend_side_handle.setParent(root) bend_upp_handle.setParent(root) bend_low_handle.setParent(root) pymel.connectAttr(root.bendSide, bend_side_deformer.curvature) pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature) pymel.connectAttr(root.bendLow, bend_low_deformer.curvature) # Rename all the things! root.rename(nomenclature.resolve('SurfaceGrp')) plane_transform.rename(nomenclature.resolve('Surface')) bend_upp_deformer.rename(nomenclature.resolve('UppBend')) bend_low_deformer.rename(nomenclature.resolve('LowBend')) bend_side_deformer.rename(nomenclature.resolve('SideBend')) bend_upp_handle.rename(nomenclature.resolve('UppBendHandle')) bend_low_handle.rename(nomenclature.resolve('LowBendHandle')) bend_side_handle.rename(nomenclature.resolve('SideBendHandle')) # Try to guess the desired position min_x = None max_x = None pos = pymel.datatypes.Vector() for jnt in self.jnts: pos += jnt.getTranslation(space='world') if min_x is None or pos.x < min_x: min_x = pos.x if max_x is None or pos.x > max_x: max_x = pos.x pos /= len(self.jnts) root.setTranslation(pos) # Try to guess the scale length_x = max_x - min_x if len(self.jnts) <= 1 or length_x < epsilon: log.debug("Cannot automatically resolve scale for surface. Using default value {0}".format(default_scale)) length_x = default_scale root.scaleX.set(length_x) root.scaleY.set(length_x * 0.5) root.scaleZ.set(length_x) pymel.select(root) # self.input.append(plane_transform) return plane_transform
def create_surface(self, name='Surface'): """ Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide a surface for the influence to slide on. :param name: The suffix of the surface name to create. :return: A pymel.nodetypes.Transform instance of the created surface. """ nomenclature = self.get_nomenclature_rig().copy() nomenclature.add_tokens(name) root = pymel.createNode('transform') pymel.addAttr(root, longName='bendUpp', k=True) pymel.addAttr(root, longName='bendLow', k=True) pymel.addAttr(root, longName='bendSide', k=True) # Create Guide plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4) # Create Bends bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform, type='bend') bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform, type='bend') bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform, type='bend') plane_transform.r.set(0, -90, 0) bend_side_handle.r.set(90, 90, 0) bend_upp_handle.r.set(180, 90, 0) bend_low_handle.r.set(180, 90, 0) bend_upp_deformer.highBound.set(0) # create pymel warning bend_low_deformer.lowBound.set(0) # create pymel warning plane_transform.setParent(root) bend_side_handle.setParent(root) bend_upp_handle.setParent(root) bend_low_handle.setParent(root) pymel.connectAttr(root.bendSide, bend_side_deformer.curvature) pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature) pymel.connectAttr(root.bendLow, bend_low_deformer.curvature) # Rename all the things! root.rename(nomenclature.resolve('SurfaceGrp')) plane_transform.rename(nomenclature.resolve('Surface')) bend_upp_deformer.rename(nomenclature.resolve('UppBend')) bend_low_deformer.rename(nomenclature.resolve('LowBend')) bend_side_deformer.rename(nomenclature.resolve('SideBend')) bend_upp_handle.rename(nomenclature.resolve('UppBendHandle')) bend_low_handle.rename(nomenclature.resolve('LowBendHandle')) bend_side_handle.rename(nomenclature.resolve('SideBendHandle')) # Try to guess the desired position min_x = None max_x = None pos = pymel.datatypes.Vector() for jnt in self.jnts: pos += jnt.getTranslation(space='world') if min_x is None or pos.x < min_x: min_x = pos.x if max_x is None or pos.x > max_x: max_x = pos.x pos /= len(self.jnts) length_x = max_x - min_x root.setTranslation(pos) root.scaleX.set(length_x) root.scaleY.set(length_x * 0.5) root.scaleZ.set(length_x) pymel.select(root) #self.input.append(plane_transform) return plane_transform
import pymel.core as pm #select all verts of number import pymel.core as pm vtxs=[] for obj in pm.ls(sl=True): vtxs.append( obj.vtx[492] ) pm.select( vtxs, r=True ) #aim some bend deformers based on two points for obj in pm.ls(sl=True): pm.select(obj, r=True) bend = pm.nonLinear( type= 'bend', curvature=0 ) pc = pm.pointConstraint( obj.name().replace('_GEO','_pc'), bend[1], mo=False ) ac = pm.aimConstraint( obj.name().replace('_GEO','_ac'), bend[1], aimVector=[0,1,0], upVector=[-1,0,0], worldUpType='scene', mo=False ) bend[0].lowBound.set(0) bend[0].highBound.set(2.65) bend[0].rename( obj.name().replace('_GEO','_BEND') ) bend[1].rename( obj.name().replace('_GEO','_BENDHandle') ) pm.delete( pc, ac ) #add nonlinear deformers from source to target sel = pm.ls(sl=True) src = sel[0] tgts = sel[1:] deformers = list(set(src.getShape().listHistory(type='nonLinear')))
def doRig(self): anchorList = [] cntrlList = [] locList = [] dummyCrv = self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv' pm.hide(pm.polyCube(n=dummyCrv)) if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']): pm.delete(self.ribbonDict['noMoveSetup']['nameTempl']) if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']): pm.delete(self.ribbonDict['moveallSetup']['nameTempl']) logger ###Estrutura que nao deve ter transformacao noMoveSpace = pm.group(empty=True, n=self.ribbonDict['noMoveSetup']['nameTempl']) if not pm.objExists('NOMOVE'): pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE') else: pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE') pm.parent(self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv', noMoveSpace) noMoveSpace.visibility.set(0) noMoveBend1 = pm.nurbsPlane(p=(self.size * 0.5, 0, 0), ax=(0, 0, 1), w=self.size, lr=0.1, d=3, u=5, v=1) # noMoveCrvJnt = pm.curve ( bezier=True, d=3, p=[(self.size*-0.5,0,0),(self.size*-0.4,0,0),(self.size*-0.1,0,0),(0,0,0),(self.size*0.1,0,0),(self.size*0.4,0,0),(self.size*0.5,0,0)], k=[0,0,0,1,1,1,2,2,2]) noMoveCrvJnt = pm.curve( bezier=True, d=3, p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0), (self.size * -0.496, 0, 0), (self.size * -0.495, 0, 0), (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0), (0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0), (self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0), (self.size * 0.499, 0, 0), (self.size * 0.50, 0, 0)], k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10]) noMoveCrvJnt.translate.set(self.size * 0.5, 0, 0) # Deformers das superficies noMove twist1 = pm.nonLinear(noMoveBend1[0], type='twist') # twist das superficies noMove twist1[1].rotateZ.set(90) # IMPLEMENTAR O TWIST DO MEIO twist2 = pm.nonLinear(noMoveBend1[0].name() + '.cv[0:3][0:3]', type='twist') # twist das superficies noMove twist2[1].rotateZ.set(90) twist3 = pm.nonLinear(noMoveBend1[0].name() + '.cv[4:7][0:3]', type='twist') # twist das superficies noMove twist3[1].rotateZ.set(90) wireDef = pm.wire(noMoveBend1[0], w=noMoveCrvJnt, dds=[(0, 50)]) # Wire das superficies noMove wireDef[0].rotation.set(1) # seta rotacao pra acontecer baseWire = [ x for x in wireDef[0].connections() if 'BaseWire' in x.name() ] pm.group(baseWire, noMoveCrvJnt, noMoveBend1[0], p=noMoveSpace, n=self.name + 'Deforms_grp') pm.parent(twist1[1], twist2[1], twist3[1], noMoveSpace) ###Estrutura que pode ser movida cntrlsSpace = pm.group(empty=True, n=self.ribbonDict['moveallSetup']['nameTempl']) bendSurf1 = pm.nurbsPlane(p=(self.size * -0.5, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1) blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0]) pm.blendShape(blend1, e=True, w=[(0, 1)]) pm.parent(bendSurf1[0], cntrlsSpace) ##Cntrls for i in range(0, 7): anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) + ']') pm.cluster(anchor[1], e=True, g=dummyCrv) clsHandle = anchor[1] anchorGrp = pm.group(em=True, n='clusterGrp' + str(i)) anchorDrn = pm.group(em=True, n='clusterDrn' + str(i), p=anchorGrp) pos = pm.xform(anchor, q=True, ws=True, rp=True) pm.xform(anchorGrp, t=pos, ws=True) pm.parent(anchor[1], anchorDrn) anchorList.append(anchor[1]) if i == 0 or i == 6: displaySetup = self.ribbonDict['cntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) elif i == 3: displaySetup = self.ribbonDict['midCntrlSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) else: displaySetup = self.ribbonDict['cntrlTangSetup'].copy() cntrlName = displaySetup['nameTempl'] + str(i) cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup) # Nao pode fazer conexao na criacao do controle, pois tera conexao direta pm.xform(cntrl.getParent(), t=pos, ws=True) # estrutura de buffers para conexao direta auxLocGrp = pm.group(em=True, n=self.name + 'auxLoc_grp') auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + 'aux_loc') pm.xform(auxLocGrp, t=pos, ws=True) loc = pm.PyNode(auxLoc) if i == 1 or i == 4: pm.xform(anchorGrp, s=(-1, 1, 1), r=True) pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True) pm.xform(loc.getParent(), s=(-1, 1, 1), r=True) # Conexoes dos buffers cm os clusters e com os controles pm.parentConstraint(cntrl, loc) loc.translate >> anchorDrn.translate loc.rotate >> anchorDrn.rotate cntrlList.append(cntrl) locList.append(loc) startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]') endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]') pm.cluster(startCls[1], e=True, g=dummyCrv) pm.cluster(endCls[1], e=True, g=dummyCrv) pm.parent(startCls, anchorList[0]) pm.parent(endCls, anchorList[6]) cntrlsSpace.addAttr('cntrlsVis', at='double', dv=1, k=True, h=False) cntrlsSpace.addAttr('extraCntrlsVis', at='double', dv=0, k=True, h=False) cntrlList[0].addAttr('twist', at='double', dv=0, k=True) cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[3].addAttr('twist', at='double', dv=0, k=True) cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True) cntrlList[6].addAttr('twist', at='double', dv=0, k=True) cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True) cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True) cntrlList[0].twist >> twist1[0].endAngle cntrlList[3].twist >> twist2[0].startAngle cntrlList[3].twist >> twist3[0].endAngle cntrlList[6].twist >> twist1[0].startAngle # hierarquia pm.parent(anchorList[1].getParent(2), anchorList[0]) pm.parent(anchorList[5].getParent(2), anchorList[6]) pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2), anchorList[3]) pm.parent(cntrlList[1].getParent(), cntrlList[0]) pm.parent(cntrlList[5].getParent(), cntrlList[6]) pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(), cntrlList[3]) pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(), cntrlList[6].getParent(), cntrlsSpace) pm.parent(locList[1].getParent(), locList[0]) pm.parent(locList[5].getParent(), locList[6]) pm.parent(locList[2].getParent(), locList[4].getParent(), locList[3]) pm.parent(locList[3].getParent(), locList[0].getParent(), locList[6].getParent(), cntrlsSpace) pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2), anchorList[6].getParent(2), noMoveSpace) # Skin joints do ribbon skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts_grp') follGrp = pm.group(em=True, n=self.name + 'Foll_grp') # cria ramps para controlar o perfil de squash e stretch ramp1 = pm.createNode('ramp', n=self.name + 'SquashRamp1') ramp1.attr('type').set(1) # ramp2 = pm.createNode ('ramp') # ramp2.attr('type').set(1) expre1 = "float $dummy = " + ramp1.name( ) + ".outAlpha;float $output[];float $color[];" # expre2 = "float $dummy = "+ramp2.name()+".outAlpha;float $output[];float $color[];" extraCntrlsGrp = pm.group(em=True, r=True, p=cntrlsSpace, n=self.name + 'extraCntrls_grp') # loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon. # cria tmb node tree pro squash/stretch # e controles extras vIncrement = float( (1.0 - (self.offsetStart + self.offsetEnd)) / (self.numJnts - 1)) for i in range(1, self.numJnts + 1): # cria estrutura pra superficie 1 pm.select(cl=True) jntName = self.ribbonDict['jntSetup']['nameTempl'] + str( i) + self.jntSulfix jnt1 = pm.joint(p=(0, 0, 0), n=jntName) self.skinJoints.append(jnt1) displaySetup = self.ribbonDict['cntrlExtraSetup'].copy() cntrlName = displaySetup['nameTempl'] + 'A' + str(i) cntrl1 = controlTools.cntrlCrv(name=cntrlName, obj=jnt1, connType='parentConstraint', **displaySetup) # node tree blend1A = pm.createNode('blendTwoAttr', n=self.name + 'VolumeBlend1A') blend1B = pm.createNode('blendTwoAttr', n=self.name + 'VolumeBlend1B') gammaCorr1 = pm.createNode('gammaCorrect', n=self.name + 'VolumeGamma1') cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX blend1A.input[0].set(1) gammaCorr1.outValueX >> blend1A.input[1] blend1B.input[0].set(1) blend1A.output >> blend1B.input[1] cntrlList[3].attr('autoVolume') >> blend1B.attributesBlender blend1B.output >> cntrl1.getParent().scaleY blend1B.output >> cntrl1.getParent().scaleZ # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str( self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name( ) + " `;$output[" + str(i) + "] = $color[0];" + blend1A.name( ) + ".attributesBlender=$output[" + str(i) + "];" # prende joints nas supeficies com follicules foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4) pm.parent(cntrl1.getParent(), extraCntrlsGrp) pm.parent(jnt1, skinJntsGrp) pm.parent(foll1, follGrp) # seta expressoes para so serem avaliadas por demanda pm.expression(s=expre1, ae=False) pm.parent(skinJntsGrp, cntrlsSpace) pm.parent(follGrp, noMoveSpace) # hideCntrls pm.toggle(bendSurf1[0], g=True) bendSurf1[0].visibility.set(0) # skinJntsGrp.visibility.set(0) cntrlsSpace.extraCntrlsVis >> extraCntrlsGrp.visibility cntrlsSpace.cntrlsVis >> cntrlList[0].getParent().visibility cntrlsSpace.cntrlsVis >> cntrlList[3].getParent().visibility cntrlsSpace.cntrlsVis >> cntrlList[6].getParent().visibility # povoa ribbon Dict self.ribbonDict['name'] = 'bezierRibbon' self.ribbonDict['ribbonMoveAll'] = cntrlsSpace for i in range(0, 7): self.ribbonDict['cntrl' + str(i)] = cntrlList[i] self.startCntrl = cntrlList[0] self.midCntrl = cntrlList[3] self.endCntrl = cntrlList[6] self.moveall = cntrlsSpace
def create(cls, geometry, type="bend", influences=None): nonlinear = pm.nonLinear(geometry, type=type)[0] return NonLinear(nonlinear)