Ejemplo n.º 1
0
 def createSrf(self):
     #calculate the witdth of the surface as a fraction of the total joint chain length
     jntChainLength = 0
     crvPoints = []
     for i in range(1,self.numJnt):
         pos1 = self.ikJntList[i-1].getTranslation(space='world')
         crvPoints.append(pos1)
         pos2 = self.ikJntList[i].getTranslation(space='world')
 
         jntChainLength += (pos2 - pos1).length()
         if i == self.numJnt - 1:
             crvPoints.append(pos2)
     
     jntChainLength = math.ceil(jntChainLength )
     self.width = jntChainLength * self.widthMult
     
     crv1 = pm.curve(n=self.name + '_crv1',d=1,p=crvPoints)
     pm.move(crv1,self.width / 2.0,0,0,r=1)
     pm.parent(crv1,self.mainGrp)
     crv2 = pm.curve(n=self.name + '_crv2',d=1,p=crvPoints)
     pm.move(crv2,self.width / -2.0,0,0,r=1)
     pm.parent(crv2,self.mainGrp)
     
     pm.select(cl=1)
     loftSrf = pm.loft(crv2,crv1,ch=1,u=1,c= 0,ar= 1,d=3,ss= 1,rn=0,po=0,rsn=1,n=self.name + "_srf")[0]
     rebuiltLoftSrf = pm.rebuildSurface(loftSrf,ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=self.numCtrl-1, du=3, sv=0, dv=3, tol=0, fr=0, dir=2 )[0]
     
     
     self.srf = loftSrf 
     pm.parent(self.srf,self.mainGrp)
Ejemplo n.º 2
0
def create_guideSurface( IdName, listOfJnts ):
    loftCurves = []
    for i in range(2):
        # duplicate and select hierarchy of joints
        listOfOffsetJnts = pm.duplicate( listOfJnts, name = 'b_' + IdName +'_offset1', parentOnly = True )
        
        # offset each joint on it's own z-axis
        for jnt in listOfOffsetJnts:
            if i == 0: pm.move(jnt, (0,0,-0.5), relative = True, objectSpace = True, preserveChildPosition = True)
            if i == 1: pm.move(jnt, (0,0,0.5), relative = True, objectSpace = True, preserveChildPosition = True)
        
        # draw loftcurves
        loftCurvePoints = []
        for each in listOfOffsetJnts:
            jntPosition = pm.xform(each, q = True, t = True, ws = True)
            loftCurvePoints.append(jntPosition)
        
        loftCurves.append( pm.curve( name = IdName + '_loftCurve' + str(i), degree = 1, point = loftCurvePoints ) ) 
        pm.delete(listOfOffsetJnts)

    # loft guideSurface
    guideSurface = pm.loft( loftCurves[0], loftCurves[1], name = IdName + '_guide_surface', ar=True, rsn=True, d=3, ss=1, object=True, ch=False, polygon=0 )
    guideSurface = pm.rebuildSurface( guideSurface ,ch=1, rpo=1, rt=0, end=1, kr=1, kcp=0, kc=0, su=0, du=3, sv=1, dv=3, tol=0.01, fr=0, dir=2 )
        
    # cleanup
    pm.delete( loftCurves )
    guideSurface[0].inheritsTransform.set(False)
    guideSurface[0].overrideEnabled.set(True)
    guideSurface[0].overrideDisplayType.set(1)
    # guideSurface[0].visibility.set(False)
    
    print('Successfully lofted guide surface. Continuing...')
    return guideSurface
Ejemplo n.º 3
0
    def buildSrf(self):
        startJntVec = om.MVector(self.start[0], self.start[1], self.start[2])
        endJntVec = om.MVector(self.end[0], self.end[1], self.end[2])
        diffVec = endJntVec - startJntVec
        self.rbnLength = diffVec.length()

        crvPoints = []
        for i in range(self.rbnSegments + 1):
            vec = startJntVec + diffVec * (i * 1.0 / self.rbnSegments)
            crvPoints.append([vec.x, vec.y, vec.z])
            # pm.spaceLocator(p=[vec.x,vec.y,vec.z])

        tmp = pm.curve(n=self.rbnName + '_crv1', d=1, p=crvPoints)
        crv1 = pm.ls(tmp)[0]
        crv1.setPivots(self.start)
        crv2 = pm.duplicate(crv1)[0]

        self.offsetCrv(crv1, -1.0 * self.rbnWidth / 2)
        self.offsetCrv(crv2, 1.0 * self.rbnWidth / 2)

        tmpLoftSrf = \
        pm.loft(crv1, crv2, ch=0, u=1, c=0, ar=1, d=1, ss=1, rn=0, po=0, rsn=1, n=self.rbnName + "_lft_srf")[0]
        rebuiltLoftSrf = \
        pm.rebuildSurface(ch=0, rpo=0, rt=0, end=1, kr=1, kcp=0, kc=0, su=0, du=3, sv=0, dv=1, fr=0, dir=2,
                          n=self.rbnName + "_srf")[0]
        rebuiltLoftSrf.setPivots(rebuiltLoftSrf.c.get())
        self.rbnSrf = rebuiltLoftSrf
        pm.delete(self.rbnSrf, ch=1)

        pm.delete([crv1, crv2, tmpLoftSrf])

        pm.parent(self.rbnSrf, self.rbnTransformGrp)
Ejemplo n.º 4
0
def CurveLoft(crv, geom, size, norDir, nm):
    try:
        crvSh = crv.listRelatives(s=1, type='nurbsCurve')[0]
    except:
        pm.warning('%s is not nurbsCurve')
        return
    tmpOC = pm.createNode('nearestPointOnCurve', n='TmpOC')
    crv.ws >> tmpOC.inputCurve
    copyCrvA = crv.duplicate(n='%sCopyACrv' % crv.name().replace('Crv', ''))[0]
    copyCrvB = crv.duplicate(n='%sCopyBCrv' % crv.name().replace('Crv', ''))[0]
    cvSz = int(crv.spans.get())
    if crv.d.get() == 3: cvSz = cvSz + 3
    upvec = dt.Vector(int(norDir[0]), int(norDir[1]), int(norDir[2]))
    for i in xrange(cvSz):
        tmpOC.inPosition.set(crv.cv[i].getPosition(space='world'))
        tVec = pm.pointOnCurve(crv, pr=tmpOC.parameter.get(), nt=1)
        cVecA = dt.cross(upvec, dt.Vector(tVec))
        cVecB = dt.cross(dt.Vector(tVec), upvec)
        pm.move(copyCrvA.cv[i], cVecA * size, r=1)
        pm.move(copyCrvB.cv[i], cVecB * size, r=1)
    geo = pm.loft(copyCrvB,
                  copyCrvA,
                  ch=1,
                  u=1,
                  c=0,
                  ar=1,
                  d=3,
                  ss=1,
                  rn=0,
                  po=int(geom),
                  rsn=1)
    mel.eval('DeleteHistory %s' % geo[0].name())
    pm.delete(tmpOC, copyCrvA, copyCrvB)
    return geo[0]
Ejemplo n.º 5
0
    def createSrf(self):
        # calculate the witdth of the surface as a fraction of the total joint chain length
        jntChainLength = 0
        crvPoints = []
        for i in range(1, self.numJnt):
            pos1 = self.ikJntList[i - 1].getTranslation(space='world')
            crvPoints.append(pos1)
            pos2 = self.ikJntList[i].getTranslation(space='world')

            jntChainLength += (pos2 - pos1).length()
            if i == self.numJnt - 1:
                crvPoints.append(pos2)

        jntChainLength = math.ceil(jntChainLength)
        self.width = jntChainLength * self.widthMult

        crv1 = pm.curve(n=self.name + '_crv1', d=1, p=crvPoints)
        pm.move(crv1, self.width / 2.0, 0, 0, r=1)
        pm.parent(crv1, self.mainGrp)
        crv2 = pm.curve(n=self.name + '_crv2', d=1, p=crvPoints)
        pm.move(crv2, self.width / -2.0, 0, 0, r=1)
        pm.parent(crv2, self.mainGrp)

        pm.select(cl=1)
        loftSrf = pm.loft(crv2, crv1, ch=1, u=1, c=0, ar=1, d=3, ss=1, rn=0, po=0, rsn=1, n=self.name + "_srf")[0]
        rebuiltLoftSrf = \
        pm.rebuildSurface(loftSrf, ch=1, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=self.numCtrl - 1, du=3, sv=0, dv=3,
                          tol=0, fr=0, dir=2)[0]

        self.srf = loftSrf
        pm.parent(self.srf, self.mainGrp)
Ejemplo n.º 6
0
def createMiddleCrv( curves=[], parameter=0.5 ):
    '''
    update : 2015-04-24
    '''
    if curves:
        curves = pm.select(curves)
    curves = pm.selected()
    if not curves:
        raise    

    surface, loft = pm.loft( 
        curves, 
        ch           = True, 
        uniform      = True, 
        close        = False, 
        autoReverse  = True, 
        degree       = 3, 
        sectionSpans = 1, 
        range        = False, 
        polygon=0,  # 0: nurbs surface 
                    # 1: polygon (use nurbsToPolygonsPref to set the parameters for the conversion) 
                    # 2: subdivision surface (use nurbsToSubdivPref to set the parameters for the conversion) 
                    # 3: Bezier surface 
                    # 4: subdivision surface solid (use nurbsToSubdivPref to set the parameters for the conversion) 
        reverseSurfaceNormals = True )

    dupCrv, crvFromSurf = pm.duplicateCurve( surface.getShape().v[ parameter ], ch=True, range=False, local=False )
    pm.delete( surface, loft, crvFromSurf )

    dupCrv = pm.PyNode( dupCrv )
    dupCrv.rename('middleCrv#')   

    return dupCrv
Ejemplo n.º 7
0
    def createRbnSrf(self):
        startJntVec = om.MVector(self.start[0], self.start[1], self.start[2])
        endJntVec = om.MVector(self.end[0], self.end[1], self.end[2])
        diffVec = endJntVec - startJntVec

        # calculate the witdth of the surface as a fraction of the total joint chain length
        jntChainLength = diffVec.length()
        self.width = jntChainLength * self.widthMult

        crvPoints = []

        for i in range(self.numCtrl):
            vec = startJntVec + diffVec * (i * 1.0 / (self.numCtrl - 1))
            crvPoints.append([vec.x, vec.y, vec.z])

        tmp = pm.curve(n=self.name + '_crv1', d=1, p=crvPoints)
        crv1 = pm.ls(tmp)[0]
        crv1.setPivots(self.start)
        crv2 = pm.duplicate(crv1)[0]

        self.offsetCrv(crv1, -1.0 * self.width / 2)
        self.offsetCrv(crv2, 1.0 * self.width / 2)

        tmpLoftSrf = pm.loft(crv1, crv2, ch=0, u=1, c=0, ar=1, d=3, ss=1, rn=0, po=0, rsn=1, n=self.name + "_tmp")[0]
        rebuiltLoftSrf = \
        pm.rebuildSurface(ch=0, rpo=0, rt=0, end=1, kr=0, kcp=0, kc=0, su=0, du=3, sv=0, dv=1, fr=0, dir=2,
                          n=self.name + "_srf")[0]
        rebuiltLoftSrf.setPivots(rebuiltLoftSrf.c.get())
        self.rbnSrf = rebuiltLoftSrf
        pm.delete(self.rbnSrf, ch=1)

        pm.delete([crv1, crv2, tmpLoftSrf])
        pm.parent(self.rbnSrf, self.mainGrp)
Ejemplo n.º 8
0
def build_plane(name=None,
                crv=None,
                spans=None,
                direction='u',
                width_axis=None,
                width=1,
                log=True):
    '''Given a valid curve, build nurbs plane

    Attributes:
        name -- Prefix name for plane. Str
        crv -- Curve to use as build guide. nt.Transform
        spans -- Spans for the plane. Int
        direction -- Build direction. 'u' or 'v'
        width_axis -- Plane width axis. 'x', 'y' or 'z'
        width -- Width of plane. Float
    '''
    general.check_type(name, 'name', [str])
    general.check_type(crv, 'crv', [pm.nt.Transform])
    general.check_type(spans, 'spans', [int])
    general.check_type(direction, 'direction', [str])
    general.check_type(width_axis, 'width_axis', [str])
    general.check_type(width, 'width', [float, int])

    if direction not in ['u', 'v']:
        raise errors.InputError('direction', direction, "'u' or 'v'")

    if width_axis not in ['x', 'y', 'z']:
        raise errors.InputError('width_axis', width_axis, "'x', 'y' or 'z'")

    d1 = crv.duplicate()
    d2 = crv.duplicate()

    move_amt = []
    if width_axis == 'x':
        move_amt = [width, 0, 0]
    elif width_axis == 'y':
        move_amt = [0, width, 0]
    elif width_axis == 'z':
        move_amt = [0, 0, width]
    if log:
        str_1 = 'move_amt: ', move_amt
        general.logging.debug(str_1)

    pm.move(move_amt[0], move_amt[1], move_amt[2], d1, r=1)

    pm.move(-move_amt[0], -move_amt[1], -move_amt[2], d2, r=1)

    p = pm.loft(d1, d2, n=name + '_plane', ch=0)[0]

    if direction == 'u':
        pm.rebuildSurface(p, dir=2, su=spans, sv=2)
    if direction == 'v':
        pm.rebuildSurface(p, dir=2, sv=spans, su=2)

    pm.delete(d1)
    pm.delete(d2)

    return p
Ejemplo n.º 9
0
def jntChainToPoly( JntRoots, ch=False, smoothBind=True ):
    '''
    조인트 체인들에 메쉬를 붙여줌.
    C:/Program Files/Autodesk/MayaBonusTools2013/scripts/bt_makeJointsDynamicUI.mel 참고할것
    '''
    curveList = []
    for root in JntRoots:
        root  = pm.PyNode(root)
        chain = root.getChildren( allDescendents=True, type='joint' )
        chain.reverse()
        chain.insert(0,root)
        curveList.append( jntToCrv( chain, degree=1, ep=False) )

    loftedSurface, loft = pm.loft( curveList, ch=1, u=1, c=0, ar=1, d=1, ss=1, rn=0, po=1, rsn=True )
    nurbsTessellate = pm.PyNode( loft.outputSurface.outputs()[0] )

    nurbsTessellate.polygonType.set(1)   # 0.Triangle, 1.Quads
    nurbsTessellate.setAttr('format', 2) # 0.Count, 1.Fit, 2.General, 3.CVs
    nurbsTessellate.uType.set(3)         # 1.Per Surf # of Isofarms in 3D, 2.Per Surf # of Isofarms, 3.Per Span # of Isofarms
    nurbsTessellate.vType.set(3)         # 1.Per Surf # of Isofarms in 3D, 2.Per Surf # of Isofarms, 3.Per Span # of Isofarms
    nurbsTessellate.uNumber.set(1)
    nurbsTessellate.vNumber.set(1)

	#polyNormalizeUV -normalizeType 1 -preserveAspectRatio off ;
    if not ch:
        pm.delete( loftedSurface, ch=True )
        pm.delete( curveList )

    if smoothBind:
        pm.select( JntRoots, hi=True )
        JNTs = pm.selected( type='joint')
        pm.skinCluster( JNTs, loftedSurface,
            toSelectedBones   = True,
            bindMethod        = 0,   # 0 - Closest distance between a joint and a point of the geometry.
                                     # 1 - Closest distance between a joint, considering the skeleton hierarchy, and a point of the geometry.
                                     # 2 - Surface heat map diffusion

            skinMethod        = 0,   # 0 - classical linear skinning (default).
                                     # 1 - dual quaternion (volume preserving),
                                     # 2 - a weighted blend between the two

            normalizeWeights  = 1,   # 0 - none,
                                     # 1 - interactive,
                                     # 2 - post (default)
            maximumInfluences = 1,
            dropoffRate       = 4,
            removeUnusedInfluence = False,
            )

        for jnt in JNTs:
            vtx = getClosestVertexOnMesh( loftedSurface, jnt.getTranslation( ws=True ) )
            setWeight( [vtx], jnt)

    return loftedSurface
Ejemplo n.º 10
0
    def bdBuildSrf(self,name):
        selected = pm.ls(sl=1)
        if selected:
            if len(selected) == 1:
                if selected[0].type() == 'joint':
                    print 'start srf'
                    self.startJnt = selected[0]
                    children = self.startJnt.getChildren(type='joint')
                    print children 
                    #need to implement a case with more joint chidren
                    #build the one degree curves for lofting
                    self.endJnt = children[0]
                    startPos1,endPos1 = self.bdGetPos(-0.05)
                    startPos2,endPos2 = self.bdGetPos( 0.05)
                    pm.spaceLocator(p=startPos1)
                    pm.spaceLocator(p=startPos2)
                    pm.spaceLocator(p=endPos1)
                    pm.spaceLocator(p=endPos2)
                    
                    dif1 = (endPos1 - startPos1) 
                    dif2 = (endPos2 - startPos2) 
                    crv1Points = []
                    crv2Points = []
                    for i in range(self.segmentsRbn):
                        pos = dif1 * (i/(self.segmentsRbn*1.0)) + startPos1
                        crv1Points.append(pos )
                        pos = dif2 * (i/(self.segmentsRbn*1.0)) + startPos2
                        crv2Points.append(pos)

                    crv1Points.append(endPos1)
                    crv2Points.append(endPos2)
                    print 'building curve'
                    tmp = pm.curve(n=name + '_crv1',d=1,p=crv1Points)
                    crv1 = pm.ls(tmp)[0]
                    print crv1
                    #crv1.setScalePivot(startPos1)
                    #crv1.setRotatePivot(startPos1)
                    crv2 = pm.curve(n=name + '_crv2',d=1,p=crv2Points)
                    #crv2.setScalePivot(startPos2)
                    #crv2.setRotatePivot(startPos2)
                    drvGrp = self.bdCreateDrvJnt(crv1,crv2)
                    
                    #loft the curves
                    loftSrf = pm.loft(crv1,crv2,ch=1,u=1,c= 0,ar= 1,d=1,ss= 1,rn=0,po=0,rsn=1,n=name + "_lft_srf")[0]
                    #loftSrf.setScalePivot(startPos2)
                    #loftSrf.setRotatePivot(startPos2)
                    rebuiltLoftSrf = pm.rebuildSurface(ch=1, rpo = 0, rt = 0, end = 1, kr=1, kcp=0,kc=0, su=0, du=3, sv=0, dv=1, fr=0, dir=2 , n=name + "_srf")[0]
                    self.rbnSrf = rebuiltLoftSrf
                    crvGrp = pm.group([crv1,crv2],name=name+'_crv_grp')
                    crvGrp.centerPivots()
                    srfGrp = pm.group([loftSrf,rebuiltLoftSrf],name=name+'_srf_grp')
                    srfGrp.centerPivots()
                    self.rbnGrp = pm.group([crvGrp,srfGrp],n=name+"_grp")
                    pm.parent(drvGrp,self.rbnGrp)
Ejemplo n.º 11
0
 def _createPlane(self, name=None, crv1=None, crv2=None):
     '''
     Plane made by lofting two curves
     '''
     _name = '_createPlane'
     pymelLogger.info('Started: %s' % _name)
     
     plane = pm.loft( crv1, crv2, ch=False, rn=True)[0]
     plane.rename('%s_plane' % name)
     
     pymelLogger.info('Ended: %s' % _name)        
     return plane
Ejemplo n.º 12
0
 def _create_ribbon(self):
     """Create the ribbon spine based on the guides."""
     ribboncrv = pm.curve(p=[ctl.position() for ctl in self.guides.spine],
                          n='%s_%sRibbon_CRV' % (self.side, self.name), d=3)
     ribboncrv.listRelatives(ad=True)[0].rename('%sShape' % ribboncrv)
     crva = pm.curve(d=1, p=[ctl.position() for ctl in self.guides.spine])
     crvb = crva.duplicate()[0]
     crva.tx.set(-1)
     crvb.tx.set(1)
     nrbname = '%s_%sRibbon_NRB' % (self.side, self.name)
     loft = pm.loft(crva, crvb, n=nrbname, ch=False)[0]
     self.ribbon = pm.rebuildSurface(loft, su=0, sv=0, ch=False)
     pm.delete(crva, crvb)
Ejemplo n.º 13
0
 def _create_ribbon(self):
     """Create the ribbon spine based on the guides."""
     ribboncrv = pm.curve(p=[ctl.position() for ctl in self.guides.spine],
                          n='%s_%sRibbon_CRV' % (self.side, self.name),
                          d=3)
     ribboncrv.listRelatives(ad=True)[0].rename('%sShape' % ribboncrv)
     crva = pm.curve(d=1, p=[ctl.position() for ctl in self.guides.spine])
     crvb = crva.duplicate()[0]
     crva.tx.set(-1)
     crvb.tx.set(1)
     nrbname = '%s_%sRibbon_NRB' % (self.side, self.name)
     loft = pm.loft(crva, crvb, n=nrbname, ch=False)[0]
     self.ribbon = pm.rebuildSurface(loft, su=0, sv=0, ch=False)
     pm.delete(crva, crvb)
Ejemplo n.º 14
0
 def create(self,control_count):
     """Generate hairMesh"""
     self.control = HairCtrlGrp(num_ctrl=control_count)
     pm.select(self.control.ctrls)
     pm.nurbsToPolygonsPref(pt=1, un=4, vn=7, f=2, ut=2, vt=2)
     hairMesh = pm.loft(n=self.name, po=1, ch=1, u=1, c=0, ar=1, d=3, ss=1, rn=0, rsn=True)
     self.transform = hairMesh[0]
     self.transform.addAttr('lengthDivisions', min=1, at='long', dv=self.lengthDivs)
     self.transform.addAttr('widthDivisions', min=4, at='long', dv=self.widthDivs)
     self.transform.setAttr('lengthDivisions', e=1, k=1)
     self.transform.setAttr('widthDivisions', e=1, k=1)
     self.tesselate = pm.listConnections(hairMesh)[-1]
     self.transform.connectAttr('widthDivisions', self.tesselate+".uNumber")
     self.transform.connectAttr('lengthDivisions', self.tesselate+".vNumber")
     self.shape = self.transform.getShape()
     self.gen_node = hairMesh[1]
Ejemplo n.º 15
0
def makeRibbon(jnts=[], axis="z"):
	if not jnts:
		jnts = pmc.ls(sl=True)
	offset = pmc.datatypes.Vector(
				[float(a == axis.lower()) for a in ["x", "y", "z"]])
	curves = []
	for j in jnts:
		if j.type() != "joint":
			pmc.error("Invalid selection. Select joints only.")
		pos = j.getTranslation(ws=True)
		c = pmc.curve(d=1, p=[(pos+offset), (pos-offset)])
		curves.append(c)
		#pmc.skinCluster(j, c, maxInfluences=1)
	#loft = pmc.loft(curves)
	loft = pmc.loft(curves, ch=False)[0]
	pmc.delete(curves)
	#pmc.skinCluster(jnts, loft, maximumInfluences=1)
	return loft
Ejemplo n.º 16
0
def makeSurfFromEdges(name="untitled_SURF_RIG", symVec=None, numSpans=None):
    """Create a surface based on the selected mesh edges"""

    sel = getSymSelection()
    if not sel or len(sel) < 2:
        pmc.warning("Surface not created. Select two or more mesh edges.")
        return
    crv = makeNiceCurveFromEdges(sel, symVec, numSpans)

    # find distance to offset curve by
    if crv.form() == "open":
        surf = makeOpenSurf(crv, sel[0].node(), name)
    else:
        crv2 = pmc.duplicate(crv)[0]
        # loops get scaled
        pmc.scale(crv, .5, .5, .5)
        pmc.scale(crv2, 1.5, 1.5, 1.5)
        surf = pmc.loft(crv, crv2, uniform=True, n=name, ch=0)[0]
        pmc.delete(crv2)
    """
    # how many spans?
    if not numSpans:
        # (x/8)*2 ensures even numSpans rather than /4
        numSpans = min(8, (len(sel)/8)*2)

    # rebuild: u is the lofted direction, v is the length direction
    # debug time - rebuild can drastically change the curvature.
    # perhaps there is a better way along the lines of mirroring CVs?
    # even though neither side is probably great if the rebuild is so
    # dependant upon seam placement...

    # or maybe not - was that just a temporary thing from debugging it?
    # keepCorners=0 to avoid weird UV texture/normal issues
    pmc.rebuildSurface(surf, rebuildType=0, rpo=1, keepRange=0, dir=2, kc=0,
                            spansU=1, spansV=numSpans, ch=0)
    """

    # determine if its normal is "backwards" - get normal of random vert,
    # then normal of surf at the closest point to that vert
    surf = orientSurf(surf, sel)
    pmc.delete(crv)

    return surf
Ejemplo n.º 17
0
def makeRibbon(jnts=None, axis="z"):
    """create a lofted surface, and kill history...
    or not? just skin "curves" to joints 1:1?"""
    if not jnts:
        jnts = pmc.ls(sl=True)
    offset = pmc.datatypes.Vector(
        [float(a == axis.lower()) for a in ["x", "y", "z"]])
    curves = []
    for j in jnts:
        if j.type() != "joint":
            pmc.error("Invalid selection. Select joints only.")
        pos = j.getTranslation(ws=True)
        c = pmc.curve(d=1, p=[(pos + offset), (pos - offset)])
        curves.append(c)
        # pmc.skinCluster(j, c, maxInfluences=1)
    # loft = pmc.loft(curves)
    loft = pmc.loft(curves, ch=False)[0]
    pmc.delete(curves)
    # pmc.skinCluster(jnts, loft, maximumInfluences=1)
    return loft
Ejemplo n.º 18
0
    def createRbnSrf(self):

        startJntVec = om.MVector(self.start[0], self.start[1], self.start[2])
        endJntVec = om.MVector(self.end[0], self.end[1], self.end[2])
        diffVec = endJntVec - startJntVec

        # calculate the witdth of the surface as a fraction of the total joint chain length
        jntChainLength = diffVec.length()
        self.width = jntChainLength * self.widthMult

        crv1 = pm.duplicate(pm.ls(self.buildCrv)[0])[0]
        crv1.setPivots(self.start)
        crv2 = pm.duplicate(crv1)[0]

        self.offsetCrv(crv1, -0.3 * self.width)
        self.offsetCrv(crv2, 0.3 * self.width)

        loftSrf = pm.loft(crv1,
                          crv2,
                          ch=0,
                          u=1,
                          c=0,
                          ar=1,
                          d=1,
                          ss=1,
                          rn=0,
                          po=0,
                          rsn=1)[0]
        loftSrf = \
        pm.rebuildSurface(ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=0, du=1, sv=0, dv=1, tol=0, fr=0, dir=2,
                          n=self.name + "_srf")[0]
        pm.rename(loftSrf, self.name + "_srf")
        loftSrf.setPivots(loftSrf.c.get())
        self.rbnSrf = loftSrf
        pm.delete(self.rbnSrf, ch=1)

        pm.delete([crv1, crv2])
        pm.parent(self.rbnSrf, self.mainGrp)
Ejemplo n.º 19
0
def buildRibbon(start,
                end,
                normal,
                numControls=3,
                name='Ribbon',
                groupName='',
                controlSpec={}):

    chain = util.getChain(start, end)
    controlChain = util.dupChain(start, end)

    if not name:
        name = 'Ribbon'

    container = util.parentGroup(chain[0])
    container.setParent(lib.getNodes.mainGroup())

    world = group(em=True)
    hide(world)
    world.setParent(container)

    #controlChain[0].setParent( container )

    crv = curve(d=1, p=[(0, 0, 0)] * len(chain))

    for i, j in enumerate(chain):
        xform(crv.cv[i], t=xform(j, q=True, ws=True, t=True), ws=True)

    dup = duplicate(crv)[0]

    # &&& Obviously need to calc the offset somehow, maybe I can use the mirror state?  Maybe not, due to asymmetry
    #offset = dt.Vector(5, 0, 0)
    offset = normal

    crv.t.set(offset)
    dup.t.set(offset * -1)

    surfaceTrans = loft(crv,
                        dup,
                        uniform=True,
                        polygon=0,
                        sectionSpans=1,
                        degree=3,
                        autoReverse=True)[0]
    surfaceTrans.setParent(world)

    delete(crv, dup)

    rebuildSurface(surfaceTrans,
                   rebuildType=0,
                   replaceOriginal=True,
                   spansU=1,
                   spansV=(len(chain) - 1) * 2,
                   dir=2,
                   degreeV=3,
                   degreeU=1)
    hide(surfaceTrans)

    surfaceShape = surfaceTrans.getShape()

    closest = createNode('closestPointOnSurface')
    surfaceShape.worldSpace >> closest.inputSurface

    vScalar = surfaceShape.minMaxRangeV.get()[1]

    #constraints = []

    for jnt, hairJoint in zip(chain, controlChain):
        #jnt.setParent(world)

        follicle = createNode('follicle')
        hide(follicle)
        trans = follicle.getParent()

        #hairJoints.append(trans)
        trans.setParent(world)

        pos = jnt.getTranslation(space='world')
        closest.inPosition.set(pos)

        surfaceShape.local >> follicle.inputSurface

        u = closest.parameterU.get()
        # closestPointOnSurface returns val in relation to the maxV but the follicle needs it normalized.
        v = closest.parameterV.get() / vScalar

        follicle.parameterU.set(u)
        follicle.parameterV.set(v)

        follicle.outTranslate >> trans.translate
        follicle.outRotate >> trans.rotate
        trans.translate.lock()
        trans.rotate.lock()
        hairJoint.setParent(trans)

    constraints = util.constrainAtoB(chain, controlChain)

    temp = core.capi.asMObject(surfaceShape)
    nurbsObj = OpenMaya.MFnNurbsSurface(temp.object())

    controls = []
    controlJoints = []
    for i in range(numControls):
        percent = i / float(numControls - 1) * vScalar
        p = pointOnSurface(surfaceShape, u=.5, v=percent, p=True)

        ctrl = controllerShape.build(
            name + '%i' % (i + 1),
            controlSpec['main'],
            type=controllerShape.ControlType.TRANSLATE)

        ctrl.t.set(p)
        j = joint(ctrl)
        hide(j)
        controlJoints.append(j)

        ctrl.setParent(container)

        # Aim the control at the next joint with it's up following the surface
        if i < numControls - 1:
            target = chain[i + 1]
            normal = nurbsObj.normal(0.5, percent)
            lib.anim.orientJoint(ctrl,
                                 target,
                                 upVector=dt.Vector(normal.x, normal.y,
                                                    normal.z))
            core.dagObj.zero(ctrl)

        controls.append(ctrl)

    # Orient the final control to the final joint
    core.dagObj.matchTo(controls[-1], chain[-1])
    core.dagObj.zero(controls[-1])

    skinCluster(surfaceShape, controlJoints, tsb=True)

    mainCtrl = nodeApi.RigController.convert(controls[0])
    mainCtrl.container = container
    for i, ctrl in enumerate(controls[1:], 1):
        mainCtrl.subControl[str(i)] = ctrl

    return mainCtrl, constraints
Ejemplo n.º 20
0
def build_plane(name=None, crv=None, spans=None,
                direction='u', width_axis=None,
                width=1, log=True):
    '''Given a valid curve, build nurbs plane

    Attributes:
        name -- Prefix name for plane. Str
        crv -- Curve to use as build guide. nt.Transform
        spans -- Spans for the plane. Int
        direction -- Build direction. 'u' or 'v'
        width_axis -- Plane width axis. 'x', 'y' or 'z'
        width -- Width of plane. Float
    '''
    general.check_type(name, 'name', [str])
    general.check_type(crv, 'crv', [pm.nt.Transform])
    general.check_type(spans, 'spans', [int])
    general.check_type(direction, 'direction', [str])
    general.check_type(width_axis, 'width_axis', [str])
    general.check_type(width, 'width', [float, int])

    if direction not in ['u', 'v']:
        raise errors.InputError('direction', direction, "'u' or 'v'")

    if width_axis not in ['x', 'y', 'z']:
        raise errors.InputError('width_axis', width_axis, "'x', 'y' or 'z'")

    d1 = crv.duplicate()
    d2 = crv.duplicate()

    move_amt = []
    if width_axis == 'x':
        move_amt = [width, 0, 0]
    elif width_axis == 'y':
        move_amt = [0, width, 0]
    elif width_axis == 'z':
        move_amt = [0, 0, width]
    if log:
        str_1 = 'move_amt: ', move_amt
        general.logging.debug(str_1)

    pm.move(move_amt[0],
            move_amt[1],
            move_amt[2],
            d1, r=1)

    pm.move(-move_amt[0],
            -move_amt[1],
            -move_amt[2],
            d2, r=1)

    p = pm.loft(d1, d2, n=name+'_plane', ch=0)[0]

    if direction == 'u':
        pm.rebuildSurface(p, dir=2, su=spans, sv=2)
    if direction == 'v':
        pm.rebuildSurface(p, dir=2, sv=spans, su=2)

    pm.delete(d1)
    pm.delete(d2)

    return p
Ejemplo n.º 21
0
    def generateProfile(self):

        n_polyType = pm.nurbsToPolygonsPref(q=1, polyType=1)
        n_format = pm.nurbsToPolygonsPref(q=1, format=1)
        n_uType = pm.nurbsToPolygonsPref(q=1, uType=1)
        n_uNumber = pm.nurbsToPolygonsPref(q=1, uNumber=1)
        n_vType = pm.nurbsToPolygonsPref(q=1, vType=1)
        n_vNumber = pm.nurbsToPolygonsPref(q=1, vNumber=1)

        self.sel_list = [
            sel for sel in pm.ls(sl=1, ni=1) if hasattr(sel, "getShape")
            and type(sel.getShape()) == pm.nodetypes.Mesh
        ]
        if not self.sel_list:
            pm.warning(u"请选择 Mesh 模型")
            pm.headsUpMessage(u"请选择 Mesh 模型")
            return

        cam = self.getActiveCamera()
        if not cam:
            pm.warning(u"请打开视窗 获取当前激活的摄像机")
            pm.headsUpMessage(u"请打开视窗 获取当前激活的摄像机")
            return

        pm.nurbsToPolygonsPref(polyType=1)
        pm.nurbsToPolygonsPref(format=2)
        pm.nurbsToPolygonsPref(uType=3)
        pm.nurbsToPolygonsPref(uNumber=1)
        pm.nurbsToPolygonsPref(vType=3)
        pm.nurbsToPolygonsPref(vNumber=1)

        self.Adjust_Layout.setEnabled(True)

        pm.undoInfo(ock=1)
        self.crv_dict = {}
        for sel in self.sel_list:
            # NOTE 通过 Toon 创建轮廓
            mel.eval('assignPfxToon "" 0;')
            # NOTE 获取 Toon 节点
            profile_node = pm.ls(sl=1)[0]
            # NOTE 链接当前摄像机 外轮廓
            cam.t.connect(profile_node.cameraPoint, f=1)

            # NOTE 生成描边曲线
            base_crv_list = self.generateProfileCurve(profile_node)

            mesh_list = []
            inflate_crv_list = []
            nurbsTessellate_list = []
            # NOTE 曲线放样成描边模型
            for base in base_crv_list:
                pm.rebuildCurve(base,
                                ch=0,
                                rpo=1,
                                rt=0,
                                end=1,
                                kr=1,
                                kcp=0,
                                kep=1,
                                kt=0,
                                s=0,
                                d=3,
                                tol=0.01)
                inflate = self.inflateCurveOnMesh(base, sel, scale=0.5)
                inflate_crv_list.append(inflate)

                mesh = pm.loft(base,
                               inflate,
                               ch=1,
                               u=1,
                               c=0,
                               ar=1,
                               d=3,
                               ss=1,
                               rn=1,
                               po=1,
                               rsn=1)[0]
                node = mesh.history(type="nurbsTessellate")
                if node:
                    nurbsTessellate_list.extend(node)

                mesh_list.append(mesh)

            self.crv_dict[sel] = {
                "base": base_crv_list,
                "inflate": inflate_crv_list,
                "mesh": mesh_list,
                "nurbsTessellate": nurbsTessellate_list,
            }

            base_grp = pm.group(base_crv_list, n="base_grp")
            inflate_grp = pm.group(inflate_crv_list, n="inflate_grp")
            # mesh_grp = pm.group(mesh_list,n="inflate_mesh_grp")

            self.profile_grp = pm.group(base_grp,
                                        inflate_grp,
                                        mesh_list,
                                        n="profile_grp")

            self.Profile_LE.setText(str(self.profile_grp))

            # if len(mesh_list) > 2:
            #     pm.polyUnite(mesh_list,n="%s_profile"%sel,ch=0)
            # pm.delete(base_grp,inflate_grp)

            pm.delete(profile_node.getParent())

        pm.undoInfo(cck=1)

        pm.nurbsToPolygonsPref(polyType=n_polyType)
        pm.nurbsToPolygonsPref(format=n_format)
        pm.nurbsToPolygonsPref(uType=n_uType)
        pm.nurbsToPolygonsPref(uNumber=n_uNumber)
        pm.nurbsToPolygonsPref(vType=n_vType)
        pm.nurbsToPolygonsPref(vNumber=n_vNumber)
Ejemplo n.º 22
0
    def surfaceCreation(self, curve):

        bindJntChain = self.jointCreation(curve)


        loftCurves = []

        i = -1

        for x in range(2):

            jntPosList = []

            chain = pm.duplicate(bindJntChain)
            chain[0].translateZ.set(i)
            i += 2

            # Getting the children of the joint chains
            for k in chain:
                jntChildPos = k.getTranslation(space='world')
                jntPosList.append(jntChildPos)

            loftCurve = pm.curve(n='curve_' + str(x), degree=1, point=jntPosList)

            loftCurves.append(loftCurve)

            pm.delete(chain)

        surface = pm.loft(loftCurves[0], loftCurves[1], n='Ribbon_Surface', ar=True, reverseSurfaceNormals=False, degree=1, ss=1, object=True, ch=False, polygon=0)
        surface = pm.rebuildSurface(surface, ch=0, rpo=1, rt=0, end=1, kr=2, kcp=0, kc=0, su=0, du=3, sv=0, dv=3, tol=0.01, fr=0, dir=2 )

        pm.delete(surface, ch=True)

        for j in loftCurves:
            pm.delete(j)

        # Unparenting joints and duplicate joints for skin
        bindJntList = []
        skinJntList = []

        for b in range(len(bindJntChain)):
            pm.parent(bindJntChain[b], w=True)
            bindJnt = pm.PyNode(bindJntChain[b])
            bindJntList.append(bindJnt)

            #Here we add the method to nodelling

            if b == len(bindJntChain)-1:
                for l in range(len(bindJntChain)):
                    name = bindJntChain[l].replace('Bind', 'Skin')
                    skinJnt = pm.duplicate(bindJntChain[l], name=name)
                    skinJntList.append(skinJnt)

        # Skinning the surface to the bind joint
        pm.skinCluster(surface, bindJntList, tsb=True, skinMethod=0, maximumInfluences=1, dropoffRate=10.0)

        # Creating all the nodes to for the skin Joints
        surfaceShape = surface[0].getShape()

        for r in range(len(skinJntList)):

            skinJnt = skinJntList[r]

            distance = (1.0 / (len(skinJntList)-1)) * r

            self.skinJntControl(skinJnt, surfaceShape, distance)
Ejemplo n.º 23
0
def plane_proxy(joints_chain, name , axis = 'z', scale = 1, type = 'mesh'):
    """ 
    Create a plane proxy for a joint chain
    
    @param joints_chain: list. List of the joints from which to create a curve
    @param name: String. Name of the final plane proxy
    @param axis: String {'x','y' or 'z'}
    
    NOTES!! : The joint chain need to be proprely oriented
    
    ## EXTERIOR CLASS BUILD
    #------------------------
    import adb_utils.adb_script_utils.Script__ProxyPlane as adbProxy
    reload (adbProxy)
    
    Proxy_plane = adbProxy.plane_proxy(pm.selected(), 'adb', 'z')
    """
    all_xmax_locs = []
    all_xmin_locs = []
    all_loc_groups = []


    def createLocs(subject):                         
        loc_align = pm.spaceLocator()
        pm.matchTransform(loc_align,subject, rot=True, pos=True)
        loc_align.sx.set(scale)
        loc_align.sy.set(scale)
        loc_align.sz.set(scale)
        return loc_align

    def createCurve(pos ,curve_name):
        knot = []
        for i in range(len(joints_chain)):
            knot.append(i)
        _curve= pm.curve(p = pos, k =knot, d=1, n=curve_name)
        # pm.rebuildCurve(_curve, rt=0, ch=0, end=1, d=3, kr=0, s=len(joints_chain), kcp=0, tol=0.1, kt=0, rpo=1, kep=1)        
        return _curve

    starting_locs = [createLocs(x) for x in joints_chain]

    for each in starting_locs:
        posBox = adbBBox.Bbox([each])
        posLocs = posBox.createPosLocs()

        posLocs_grp = pm.group(posLocs, n= '{}__grp__'.format(each) )
        all_loc_groups.append(posLocs_grp)
        pm.xform(posLocs_grp, cp=True)
        pm.matchTransform(posLocs_grp, each, pos=True, rot=True)

        if axis == 'y':
            max_value = posLocs[1]
            all_xmax_locs.append(max_value)

            min_value = posLocs[4]
            all_xmin_locs.append(min_value)
        
        elif axis == 'x':
            max_value = posLocs[3]
            all_xmax_locs.append(max_value)
            min_value = posLocs[0]
            all_xmin_locs.append(min_value)

        elif axis == 'z':
            max_value = posLocs[-1]
            all_xmax_locs.append(max_value)

            min_value = posLocs[2]
            all_xmin_locs.append(min_value)
            
    pos_locs_xmax = [createLocs(x) for x in all_xmax_locs]
    all_xmax_values = [x.getTranslation() for x in pos_locs_xmax]

    pos_locs_xmin = [createLocs(x) for x in all_xmin_locs]
    all_xmin_values = [x.getTranslation() for x in pos_locs_xmin]

    curve1 = createCurve(all_xmax_values, 'max_curve')
    curve2 = createCurve(all_xmin_values, 'min_curve')

    if type == 'mesh':
        nurbs_plane = pm.loft(curve1, curve2, c=0, ch=0, reverseSurfaceNormals = True, d=1, ar=1, u=1, rn=1, po=0)[0]
        plane_msh = pm.nurbsToPoly(nurbs_plane, n=name, uss=1, ch=0, ft=0.01, d=0.1, pt=1, f=2, mrt=0, mel=0.001, ntr=0, vn=1, pc=100, chr=0.1, un=len(pm.PyNode(curve2).getShape().getCVs()), 
        vt=1, ut=1, ucr=0, cht=0.2, mnd=1, es=0, uch=0)[0]
        pm.delete(nurbs_plane)
        
    elif type == 'nurbs':
        pm.rebuildCurve(curve1, rt=0, ch=0, end=1, d=3, kr=0, s=len(joints_chain), kcp=0, tol=0.1, kt=0, rpo=1, kep=1)
        pm.rebuildCurve(curve2, rt=0, ch=0, end=1, d=3, kr=0, s=len(joints_chain), kcp=0, tol=0.1, kt=0, rpo=1, kep=1)
        plane_msh = pm.loft(curve1, curve2, n=name, c=0, ch=0, reverseSurfaceNormals = True, d=1, ar=1, u=1, rn=1, po=0)[0]
              
    mc.DeleteHistory(plane_msh)
    mc.CenterPivot(plane_msh)
    
    ## cleanUp
    pm.delete(starting_locs, all_loc_groups, pos_locs_xmax, pos_locs_xmin)
    pm.delete(curve1)
    pm.delete(curve2)
            
    return plane_msh
    
    
# plane_proxy(pm.selected(), 'proxy' , axis = 'x', type = 'mesh')
    
    
Ejemplo n.º 24
0
def createHairMesh(profilesList,
                   name="hairMesh#",
                   cSet="hairCrease",
                   mat="",
                   lengthDivs=7,
                   widthDivs=4):
    '''create a Hair Tube with auto crease and material from list of Curve Profiles'''
    print profilesList
    if not profilesList or all(
        [type(o.getShape()) != pm.nodetypes.NurbsCurve for o in profilesList]):
        print "no Profiles"
        return
    pm.select(profilesList)
    pm.nurbsToPolygonsPref(pt=1, un=4, vn=7, f=2, ut=2, vt=2)
    HairMesh = pm.loft(n=name,
                       po=1,
                       ch=1,
                       u=1,
                       c=0,
                       ar=1,
                       d=3,
                       ss=1,
                       rn=0,
                       rsn=True)
    ###
    #lock all Transform
    lockTransform(HairMesh[0])
    #custom Attribute add
    HairMesh[0].addAttr('lengthDivisions', min=1, at='long', dv=lengthDivs)
    HairMesh[0].addAttr('widthDivisions', min=4, at='long', dv=widthDivs)
    HairMesh[0].setAttr('lengthDivisions', e=1, k=1)
    HairMesh[0].setAttr('widthDivisions', e=1, k=1)
    HairTess = pm.listConnections(HairMesh)[-1]
    HairMesh[0].connectAttr('widthDivisions', HairTess + ".uNumber")
    HairMesh[0].connectAttr('lengthDivisions', HairTess + ".vNumber")
    HairMeshShape = HairMesh[0].getShape()
    ###
    #set Crease
    pm.select(HairMeshShape.e[0, 2], r=1)
    pm.runtime.SelectEdgeLoopSp()
    sideEdges = pm.selected()
    if bool(pm.ls(cSet, type=pm.nodetypes.CreaseSet)):
        hsSet = pm.ls(cSet, type=pm.nodetypes.CreaseSet)[0]
    else:
        hsSet = pm.nodetypes.CreaseSet(name=cSet)
        hsSet.setAttr('creaseLevel', 2.0)
    for e in sideEdges:
        pm.sets(hsSet, forceElement=e)
    #assign Texture
    HairUV = HairMeshShape.map
    pm.polyEditUV(HairUV, pu=0.5, pv=0.5, su=0.3, sv=1)
    pm.polyEditUV(HairUV, u=rand.uniform(-0.1, 0.1))
    ###
    #Add Vray OpenSubdiv
    pm.select(HairMesh[0], r=1)
    addVrayOpenSubdivAttr()
    ###
    #set Smoothness
    pm.displaySmoothness(po=3)
    ###
    #set Material
    if bool(pm.ls(mat, type=pm.nodetypes.ShadingEngine)):
        pm.sets(pm.ls(mat)[0], forceElement=HairMesh[0])
    return HairMesh
Ejemplo n.º 25
0
    def __ikJj(self):    
        
        self.ikJj = []
        #create IKRibbonSpine
        #ribbon spine info:
        curveInfo = [0,(self.segment - 1) / 4,(self.segment - 1) / 2,
                     ((self.segment - 1) / 2 + (self.segment - 1)) / 2,
                     (self.segment - 1)]
        ribbonCurve = []
        self.folList = []
        
        #create curve
        for jjInfo in curveInfo:
            ribonJjPos = self.spineFkBlendChain.chain[jjInfo].getTranslation(space = 'world') 
            ribbonCurve.append(ribonJjPos)
        
        #set ribbon offset
        offset = float(self.length * 0.05)
        
        #set ribbon cur
        ribbonCurveL = pm.curve(d = 3,p = [ribbonCurve[0],ribbonCurve[1],ribbonCurve[2],ribbonCurve[3],ribbonCurve[4]],
                                k = [0,0,0,1,2,2,2],n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbonL','gud'))

        pm.move(offset,0,0,ribbonCurveL)         

        ribbonCurveR = pm.curve(d = 3,p = [ribbonCurve[0],ribbonCurve[1],ribbonCurve[2],ribbonCurve[3],ribbonCurve[4]],
                                k = [0,0,0,1,2,2,2],n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbonR','gud')) 
         
        pm.move(-offset,0,0,ribbonCurveR)     
        
        ribbonCurveR.setParent(self.guideGrp)
        ribbonCurveL.setParent(self.guideGrp)
        
        #create ribbon surf
        ribbonGeo = pm.loft(ribbonCurveR,ribbonCurveL,ch = 0,u = 1,c = 0,ar = 1,d = 3,ss = 1, rn = 0,po = 0,rsn = 1,
                             n = nameUtils.getUniqueName(self.side,self.baseName + '_ribbon','surf'))
        
        ribbonClusList = []
        self.ribbonJc = []
        self.spineCc = []
        
        #get loc pos
        for num,loc in enumerate(self.fkGuides):
            startLoc = self.fkGuides[0]
            midLoc = self.fkGuides[(len(self.fkGuides) - 1) / 2]
            endLoc = self.fkGuides[-1]
             
            startLocPos = pm.xform(startLoc,ws = 1,t = 1,q = 1)[1]
            midLocPos = pm.xform(midLoc,ws = 1,t = 1,q = 1)[1]
            endLocPos = pm.xform(endLoc,ws = 1,t = 1,q = 1)[1]
        
        #get Jc pos
        for num in [0,2,4]:
            pos = pm.select(ribbonGeo[0] + '.cv[' + str(num) + '][0:3]',r = 1)
            clus = pm.cluster()
            pm.rename(clus[1],nameUtils.getUniqueName(self.side,self.baseName + '_ribbon','cls'))
            ribbonClusList.append(clus)
            pm.select(cl = 1)
             
        #set cvpos
        for vert in [1,3]:
            for row in range(0,4):
                cvNum = pm.select(ribbonGeo[0] + '.cv[' + str(vert) + '][' + str(row) + ']',r = 1)
                oriPos = pm.xform(cvNum,ws = 1,t = 1,q = 1)
                if vert == 1:
                    pm.xform(cvNum,ws = 1,t = (oriPos[0],(startLocPos + midLocPos) / 2,oriPos[2]))
                elif vert == 3:
                    pm.xform(cvNum,ws = 1,t = (oriPos[0],(endLocPos + midLocPos) / 2,oriPos[2])) 
             
        #set Jc and Jc ctrl    
        for num,x in enumerate(ribbonClusList):
            jc = pm.joint(p = x[1].getRotatePivot(),
                          n = nameUtils.getUniqueName(self.side,self.baseName + self.nameList[num],'jc'),
                          radius = self.length / 3)
            self.ribbonJc.append(jc)
            pm.select(cl = 1)
            pm.delete(ribbonClusList[num])
            pm.select(cl = 1)
            cc = control.Control(self.side,self.baseName + self.nameList[num],size = self.ikSize,aimAxis = self.ctrlAxis)
            cc.circleCtrl()
            pm.makeIdentity(cc.control,apply = True,t=0,r=1,s=0,n=0,pn=1)
#             self.bodyCtrl.control.ik_vis.connect(cc.controlGrp.v)
            self.bodyCtrl.control.ik_vis.connect(cc.control.getShape().v)
            self.spineCc.append(cc.control)
            control.lockAndHideAttr(cc.control,['sx','sy','sz','v'])
            pm.xform(cc.controlGrp,ws = 1,matrix = jc.worldMatrix.get())
        
        #skin Jc
        for num,jc in enumerate(self.ribbonJc):
            jc.setParent(self.spineCc[num])

        ribbonSkin = pm.skinCluster(self.ribbonJc[0],self.ribbonJc[1],self.ribbonJc[2],ribbonGeo[0],
                       tsb = 1,ih = 1,mi = 3,dr = 4,rui = 1,n = nameUtils.getSkinName())
        
        #skin 
        pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[0][0:3]', transformValue=[(self.ribbonJc[0],1)])
        pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[1][0:3]', transformValue=[(self.ribbonJc[1],0.5),(self.ribbonJc[0],0.5)])
        pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[2][0:3]', transformValue=[(self.ribbonJc[1],1)])
        pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[3][0:3]', transformValue=[(self.ribbonJc[1],0.5),(self.ribbonJc[2],0.5)])
        pm.skinPercent(ribbonSkin,ribbonGeo[0] + '.cv[4][0:3]', transformValue=[(self.ribbonJc[2],1)])    
        
        #set fol
        #create / rename fol
        self.folGrp = pm.group(em = 1,n = nameUtils.getUniqueName(self.side,self.baseName + 'Fol','grp')) 
        
        for fol in range(0,self.segment):
            
            #createNodeName
            follicleTransName = nameUtils.getUniqueName(self.side,self.baseName,'fol')
            follicleShapeName = nameUtils.getUniqueName(self.side,self.baseName,'folShape')
            
            #createNode
            follicleShape = pm.createNode('follicle',n = follicleShapeName)
            follicleTrans = pm.listRelatives(follicleShape, parent=True)[0]
            follicleTrans = pm.rename(follicleTrans, follicleTransName)
            
            # connect the surface to the follicle
            if ribbonGeo[0].getShape().nodeType() == 'nurbsSurface':
                pm.connectAttr((ribbonGeo[0] + '.local'), (follicleShape + '.inputSurface'))
                
            #Connect the worldMatrix of the surface into the follicleShape
            pm.connectAttr((ribbonGeo[0].getShape() + '.worldMatrix[0]'), (follicleShape + '.inputWorldMatrix'))
            
            #Connect the follicleShape to it's transform
            pm.connectAttr((follicleShape + '.outRotate'), (follicleTrans + '.rotate'))
            pm.connectAttr((follicleShape + '.outTranslate'), (follicleTrans + '.translate'))
            
            #Set the uValue and vValue for the current follicle
            pm.setAttr((follicleShape + '.parameterV'), 0.5)
            pm.setAttr((follicleShape + '.parameterU'), float(1.0 / float(self.segment - 1)) * fol)

            #Lock the translate/rotate of the follicle
            pm.setAttr((follicleTrans + '.translate'), lock=True)
            pm.setAttr((follicleTrans + '.rotate'), lock=True)
            pm.setAttr((follicleShape + '.degree'),1)
            
            #parent
            self.folList.append(follicleTrans)
            follicleTrans.setParent(self.folGrp)
        
        #rebuild fol pos
        self.spineIkBlendJoint = []
        self.stretchCube = []
        for num,fol in enumerate(self.folList):
            jj = pm.joint(p = (0,0,0),n = nameUtils.getUniqueName(self.side,self.baseName,'jj'),
                          radius = self.length / 5)
            self.spineIkBlendJoint.append(jj)
            jj.setParent(fol)
            tempCube = pm.polyCube(ch = 1,o = 1,w = float(self.length / 5),h = float(self.length / 10),
                                   d = float(self.length / 5),cuv = 4,n = nameUtils.getUniqueName(self.side,self.baseName,'cube'))
            tempCube[0].setParent(jj)
            tempCube[0].v.set(0)
            self.stretchCube.append(tempCube[0])
            jj.translateX.set(0)
            jj.translateY.set(0)
            jj.translateZ.set(0)
            self.ikJj.append(jj)
            
        #create spine grp
        self.spineIkGrp = pm.group(self.spineCc[0].getParent(),self.spineCc[1].getParent(),self.spineCc[2].getParent(),self.folGrp,ribbonGeo[0],
                                   n = nameUtils.getUniqueName(self.side,self.baseName + 'Ik','grp'))
        ribbonGeo[0].inheritsTransform.set(0)
        self.folGrp.inheritsTransform.set(0)
        
        #clean
        self.spineIkGrp.setParent(self.bodyCtrl.control)
        
        #temp
        self.spineIkGrp.v.set(1)
        
        '''put chest ctrl under chest cc'''
        '''put leg under hip cc'''
Ejemplo n.º 26
0
    def ctrlCurve(self, parent=None):

        self.curve = pm.curve(n=self.name + '_curve', d=1, p=self.ikhCoordList)
        if parent:
            self.curve.setParent(parent)
        pm.rebuildCurve(self.curve, s=3, d=3)

        # criando cluster a cada dois cvs
        clusterDrivers = []  # clusters
        curveCtrls = []  # ctrls
        cvsToCluster = []
        poleCoords = []
        drvPtvList = []  # coords de pvt dos tres drivers
        drvOrientList = []  # orientacao dos drivers
        bendCtrlList = []

        index = 0
        curveDrvGrp = groupTools.makeGroup(name=self.name + '_curveDrv',
                                           parent=parent)
        curveDrvGrp.v.set(0)
        ctrlGrp = groupTools.makeGroup(name=self.name + '_ctrl', parent=parent)

        # criando ctrl master e parenteando os outros nele:
        masterZeroGrp = groupTools.makeGroup(name=self.name + '_master_zero',
                                             parent=ctrlGrp)
        self.masterCtrl = groupTools.makeGroup(name=self.name + '_master_ctrl',
                                               suffix='',
                                               parent=masterZeroGrp)

        masterShape = pm.duplicate(self.curve)[0]
        masterShape.translateZ.set(-25)

        # criando uma rbbn para orientar os pose readers das penas:
        rbbnName = self.name + '_aimRbbn'
        self.aimRbbn = pm.loft(self.curve,
                               masterShape,
                               ch=False,
                               ar=True,
                               d=1,
                               n=rbbnName)[0]
        self.aimRbbn.setParent(parent)
        self.aimRbbn.v.set(0)

        for e, cv in enumerate(self.curve.cv):
            if e == 0 or e == len(self.curve.cv) - 1:
                poleCoords.append(vtxWalk.bbox(cv)['globalPvt'])

            cvsToCluster.append(cv)
            for eachSpam in range(2):
                cvsToCluster.append(
                    str(self.aimRbbn.name()) + '.cv[' + str(eachSpam) + '][' +
                    str(e) + ']')

            index += 1
            if index == 2:
                cluster = pm.cluster(cvsToCluster,
                                     n=self.name + '_' + str((e / 2) + 1))[1]
                cluster.setParent(curveDrvGrp)
                clusterDrivers.append(cluster)

                index = 0
                cvsToCluster = []

        # ajustando pivos dos clusters das extremidades para os extremos
        pm.xform(clusterDrivers[0], rp=poleCoords[0], ws=1)
        pm.xform(clusterDrivers[2], rp=poleCoords[1], ws=1)

        # criando drv ctrls para a curva
        for e, drv in enumerate(clusterDrivers):
            currentPvt = pm.xform(clusterDrivers[e], rp=1, q=1, ws=1)
            ctrl = controlTools.cntrlCrv(name=self.name + '_' + str(e + 1),
                                         size=20,
                                         coords=(currentPvt, (0, 0, 0), (1, 1,
                                                                         1)),
                                         parent=ctrlGrp,
                                         lockChannels=[
                                             'v',
                                         ],
                                         color=(.9, .9, 0))
            drvPtvList.append(currentPvt)
            curveCtrls.append(ctrl)

        # orientando drv ctrls:
        for i, ctrl in enumerate(curveCtrls):
            target = ctrl.getParent()
            if i == 0:
                source = curveCtrls[1]
                aim = (1, 0, 0)

            elif i == 1:
                source = curveCtrls[2]
                aim = (1, 0, 0)

            elif i == 2:
                source = curveCtrls[1]
                aim = (-1, 0, 0)

            tempConstraint = pm.aimConstraint(source,
                                              target,
                                              wut='scene',
                                              aim=aim,
                                              mo=0)
            pm.delete(tempConstraint)
            drvOrientList.append(pm.xform(ctrl, q=1, ro=1, ws=1))

            # contraint do controle para os clusters:

            pm.parentConstraint(ctrl, clusterDrivers[i], mo=1)
            pm.scaleConstraint(ctrl, clusterDrivers[i], mo=1)

        pm.xform(masterZeroGrp, t=drvPtvList[1], ro=drvOrientList[1], ws=1)

        masterShape.setParent(self.masterCtrl)
        pm.makeIdentity(masterShape, t=1, r=1, apply=1)

        pm.parent(masterShape.getShape(), self.masterCtrl, r=1, s=1)
        pm.delete(masterShape)
        self.curve.getShape().template.set(1)

        for ctrl in curveCtrls:
            ctrl.getParent().setParent(self.masterCtrl)

        # ctrls de bend:

        bendCtrl1 = controlTools.cntrlCrv(name=self.name + '_bend1',
                                          icone='trianguloZ',
                                          size=15,
                                          lockChannels=['v'],
                                          coords=(drvPtvList[0],
                                                  drvOrientList[0], (1, 1, 1)),
                                          parent=ctrlGrp,
                                          color=(0, .1, .5))
        pm.xform(bendCtrl1, t=(0, 0, 40), ro=(0, 90, 0), r=1)
        pm.makeIdentity(bendCtrl1, r=1, apply=1)
        bendCtrl1.getParent().setParent(curveCtrls[0])
        bendCtrlList.append(bendCtrl1)

        bendCtrl2 = controlTools.cntrlCrv(name=self.name + '_bend2',
                                          icone='trianguloZ',
                                          size=15,
                                          lockChannels=['v'],
                                          coords=(drvPtvList[2],
                                                  drvOrientList[2], (1, 1, 1)),
                                          parent=ctrlGrp,
                                          color=(0, .1, .5))
        pm.xform(bendCtrl2, t=(0, 0, 40), ro=(0, -90, 0), r=1)
        pm.makeIdentity(bendCtrl2, r=1, apply=1)
        bendCtrl2.getParent().setParent(curveCtrls[2])
        bendCtrlList.append(bendCtrl2)

        return self.masterCtrl, curveCtrls, bendCtrlList
locator_num = total_joint

for i in range(locator_num):
    new_locator = pm.duplicate(startlocator)
    movelen = steplen * (i + 1)
    pm.move(movelen,new_locator, x = True,r=True, os = True)
    pointlist.append(pm.xform(new_locator,t = True, ws = True, q = True))

#create curve
#move curve along z axis
curve1 = pm.curve(p = pointlist,d = 1.0)
curve2 = pm.duplicate(curve1)
pm.move(2, curve1, x = True, r = True, os = True)
pm.move(-2, curve2, x = True, r = True, os = True)

flexymesh_transform = pm.loft(curve1, curve2, ar = True, d = 3, name = 'flexymesh', po = 0, rsn = True)[0]
#surface need to rebuild
pm.rebuildSurface(flexymesh_transform, du = 3, dv = 1, su = total_joint, sv = 1)
flexymesh = flexymesh_transform.getShape()

foll_grp = pm.group(em = True, w = True, n = 'FollicleNode')
#create follicles
for i in range (5):
    foll_transform = pm.createNode('transform', ss= True, name = 'follicle' + str(i))
    follicle = pm.createNode('follicle', name = 'follicleshape' + str(i), p = foll_transform)
    flexymesh.local.connect(follicle.inputSurface)
    flexymesh.worldMatrix[0].connect(follicle.inputWorldMatrix)
    follicle.outRotate.connect(follicle.getParent().rotate)
    follicle.outTranslate.connect(follicle.getParent().translate)
    follicle.parameterU.set(0.1 + i * 0.2)
    follicle.parameterV.set(0.5)
Ejemplo n.º 28
0
    def create_ribbons(self, side, components_type, selection, how_many_ctrls):
        if components_type != "face":
            if components_type == "edge":
                vertices_from_selection = pmc.polyListComponentConversion(selection, fromEdge=1, toVertex=1)
                vertices = pmc.ls(vertices_from_selection, flatten=1)

                vertices_from_first_edge = pmc.ls(pmc.polyListComponentConversion(selection[0], fromEdge=1, toVertex=1), flatten=1)

                edges_from_point = pmc.ls(pmc.polyListComponentConversion(vertices_from_first_edge[0], fromVertex=1, toEdge=1), flatten=1)
                vertices_from_edges = pmc.ls(pmc.polyListComponentConversion(edges_from_point, toVertex=1, fromEdge=1, border=1), flatten=1)
                next_vertex = [vertex for vertex in vertices_from_edges if vertex in vertices]
                if len(next_vertex) == 1:
                    first_vertex = pmc.ls(vertices_from_first_edge[0])[0]
                else:
                    first_vertex = pmc.ls(vertices_from_first_edge[1])[0]

                vertices.remove(first_vertex)
                vertices.insert(0, first_vertex)

            else:
                vertices = selection

            ordered_vertices = rig_lib.continuous_check_and_reorder_vertex_list(vertices, self.model.module_name)

            vertices_world_pos = []
            skn_jnts = []
            for i, vertex in enumerate(ordered_vertices):
                vertices_world_pos.append(pmc.xform(vertex, q=1, ws=1, translation=1))
                pmc.select(cl=1)
                jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_{2}_SKN".format(self.model.module_name, side, i))
                jnt.setAttr("translate", vertices_world_pos[i])
                jnt.setAttr("radius", 0.1)
                skn_jnts.append(jnt)

            front_curve = pmc.curve(d=3, p=vertices_world_pos, n="{0}_{1}_nurbsSurface_guide_01".format(self.model.module_name, side))
            back_curve = pmc.duplicate(front_curve, n="{0}_{1}_nurbsSurface_guide_02".format(self.model.module_name, side))[0]

            if self.model.loft_axis == "X":
                front_curve.setAttr("translateX", 0.1)
                back_curve.setAttr("translateX", -0.1)
            elif self.model.loft_axis == "Y":
                front_curve.setAttr("translateY", 0.1)
                back_curve.setAttr("translateY", -0.1)
            else:
                front_curve.setAttr("translateZ", 0.1)
                back_curve.setAttr("translateZ", -0.1)

            surface = pmc.loft(back_curve, front_curve, ar=1, ch=0, d=1, uniform=0, n="{0}_{1}_ribbons_NURBSSURFACE".format(self.model.module_name, side))[0]
            surface = pmc.rebuildSurface(surface, ch=0, du=1, dv=3, dir=2, kcp=1, kr=0, rt=0, rpo=1)[0]

            pmc.delete(front_curve)
            pmc.delete(back_curve)

            pmc.parent(surface, self.parts_grp)

            self.jnts_to_skin.append(skn_jnts)

            follicles = []
            for i, jnt in enumerate(skn_jnts):
                follicle_shape = pmc.createNode("follicle", n="{0}_{1}_{2}_FOLShape".format(self.model.module_name, side, i))
                follicle = follicle_shape.getParent()
                follicle.rename("{0}_{1}_{2}_FOL".format(self.model.module_name, side, i))

                follicle_shape.outTranslate >> follicle.translate
                follicle_shape.outRotate >> follicle.rotate
                surface.getShape().local >> follicle_shape.inputSurface
                surface.getShape().worldMatrix[0] >> follicle_shape.inputWorldMatrix

                point_on_surface = pmc.createNode("closestPointOnSurface", n=str(jnt) + "CPS")
                surface.getShape().local >> point_on_surface.inputSurface
                point_on_surface.setAttr("inPosition", pmc.xform(jnt, q=1, ws=1, translation=1))

                follicle_shape.setAttr("parameterU", point_on_surface.getAttr("parameterU"))
                follicle_shape.setAttr("parameterV", point_on_surface.getAttr("parameterV"))

                pmc.delete(point_on_surface)

                pmc.parent(jnt, follicle, r=0)

                follicles.append(follicle)
                pmc.parent(follicle, self.jnt_input_grp)

            pmc.select(cl=1)
            start_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_start_JNT".format(self.model.module_name, side))
            start_jnt.setAttr("radius", 0.2)
            pmc.select(cl=1)
            end_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_end_JNT".format(self.model.module_name, side))
            end_jnt.setAttr("radius", 0.2)
            pmc.select(cl=1)
            mid_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_mid_JNT".format(self.model.module_name, side))
            mid_jnt.setAttr("radius", 0.2)
            pmc.select(cl=1)
            start_mid_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_start_mid_JNT".format(self.model.module_name, side))
            start_mid_jnt.setAttr("radius", 0.2)
            pmc.select(cl=1)
            mid_end_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_mid_end_JNT".format(self.model.module_name, side))
            mid_end_jnt.setAttr("radius", 0.2)

            ctrl_jnts_pos = pmc.createNode("pointOnSurfaceInfo", n="{0}_{1}_PSI".format(self.model.module_name, side))
            surface.getShape().local >> ctrl_jnts_pos.inputSurface
            ctrl_jnts_pos.setAttr("parameterU", 0.5)

            ctrl_jnts_pos.setAttr("parameterV", 0.0)
            pmc.refresh()
            start_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

            if how_many_ctrls == "7":
                ctrl_jnts_pos.setAttr("parameterV", 0.3)
            else:
                ctrl_jnts_pos.setAttr("parameterV", 0.25)
            pmc.refresh()
            start_mid_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

            ctrl_jnts_pos.setAttr("parameterV", 0.5)
            pmc.refresh()
            mid_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

            if how_many_ctrls == "7":
                ctrl_jnts_pos.setAttr("parameterV", 0.7)
            else:
                ctrl_jnts_pos.setAttr("parameterV", 0.75)
            pmc.refresh()
            mid_end_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

            ctrl_jnts_pos.setAttr("parameterV", 1.0)
            pmc.refresh()
            end_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

            if how_many_ctrls == "7":
                pmc.select(cl=1)
                start_quarter_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_start_quarter_JNT".format(self.model.module_name, side))
                start_quarter_jnt.setAttr("radius", 0.2)
                pmc.select(cl=1)
                quarter_end_jnt = pmc.joint(p=(0, 0, 0), n="{0}_{1}_quarter_end_JNT".format(self.model.module_name, side))
                quarter_end_jnt.setAttr("radius", 0.2)

                ctrl_jnts_pos.setAttr("parameterV", 0.15)
                pmc.refresh()
                start_quarter_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

                ctrl_jnts_pos.setAttr("parameterV", 0.85)
                pmc.refresh()
                quarter_end_jnt.setAttr("translate", ctrl_jnts_pos.getAttr("position"))

                ctrls_jnt = [start_jnt, start_quarter_jnt, start_mid_jnt, mid_jnt, mid_end_jnt, quarter_end_jnt, end_jnt]
            else:
                ctrls_jnt = [start_jnt, start_mid_jnt, mid_jnt, mid_end_jnt, end_jnt]

            pmc.delete(ctrl_jnts_pos)

            ctrls = []
            ctrls_fol = []
            for jnt in ctrls_jnt:
                if side == "bot":
                    jnt.setAttr("jointOrientX", 180)

                if jnt.getAttr("translateX") < -0.05:
                    jnt.setAttr("jointOrientY", 180)

                follicle_shape = pmc.createNode("follicle", n=str(jnt).replace("_JNT", "_FOLShape"))
                follicle = follicle_shape.getParent()
                follicle.rename(str(jnt).replace("_JNT", "_FOL"))

                follicle_shape.outTranslate >> follicle.translate
                follicle_shape.outRotate >> follicle.rotate
                self.mesh_to_follow.getShape().outMesh >> follicle_shape.inputMesh
                self.mesh_to_follow.getShape().worldMatrix[0] >> follicle_shape.inputWorldMatrix

                point_on_mesh = pmc.createNode("closestPointOnMesh", n=str(jnt) + "CPM")
                self.mesh_to_follow.getShape().outMesh >> point_on_mesh.inMesh
                point_on_mesh.setAttr("inPosition", pmc.xform(jnt, q=1, ws=1, translation=1))

                follicle_shape.setAttr("parameterU", point_on_mesh.getAttr("parameterU"))
                follicle_shape.setAttr("parameterV", point_on_mesh.getAttr("parameterV"))

                pmc.delete(point_on_mesh)
                ctrls_fol.append(follicle)

                pmc.select(clear=1)
                ctrl_shape = pmc.circle(c=(0, 0, 0), nr=(0, 0, 1), sw=360, r=0.5, d=3, s=8,
                                        n=str(jnt).replace("_JNT", "_ctrl_Shape"), ch=0)[0]
                ctrl = rig_lib.create_jnttype_ctrl(name=str(jnt).replace("_JNT", "_CTRL"), shape=ctrl_shape)

                pmc.select(clear=1)
                ctrl_ofs = pmc.joint(p=(0, 0, 0), n=str(ctrl).replace("_CTRL", "_ctrl_OFS"))
                ctrl_ofs.setAttr("drawStyle", 2)

                ctrl_fix_r = pmc.joint(p=(0, 0, 0), n=str(ctrl).replace("_CTRL", "_ctrl_rotate_FIX"))
                ctrl_fix_r.setAttr("drawStyle", 2)
                ctrl_fix_r.setAttr("rotateOrder", 5)

                ctrl_fix_t = pmc.joint(p=(0, 0, 0), n=str(ctrl).replace("_CTRL", "_ctrl_translate_FIX"))
                ctrl_fix_t.setAttr("drawStyle", 2)

                pmc.parent(ctrl, ctrl_fix_t)
                pmc.parent(ctrl_ofs, follicle)

                ctrl_ofs.setAttr("translate", (0, 0, 0))
                ctrl_ofs.setAttr("rotate", (0, 0, 0))
                ctrl_ofs.setAttr("jointOrient", (0, 0, 0))

                ctrl_ofs_orientation_loc = pmc.spaceLocator(p=(0, 0, 0), n="{0}_orientation_LOC".format(ctrl_ofs))
                pmc.parent(ctrl_ofs_orientation_loc, jnt, r=1)
                pmc.parent(ctrl_ofs_orientation_loc, follicle, r=0)
                ctrl_ofs.setAttr("jointOrient", ctrl_ofs_orientation_loc.getAttr("rotate"))
                pmc.delete(ctrl_ofs_orientation_loc)

                invert_ctrl_translate = pmc.createNode("multiplyDivide", n=str(ctrl) + "invert_translate_MDL")
                invert_ctrl_rotate = pmc.createNode("multiplyDivide", n=str(ctrl) + "invert_rotate_MDL")

                ctrl.translate >> invert_ctrl_translate.input1
                invert_ctrl_translate.setAttr("input2", (-1, -1, -1))
                invert_ctrl_translate.output >> ctrl_fix_t.translate

                ctrl.rotate >> invert_ctrl_rotate.input1
                invert_ctrl_rotate.setAttr("input2", (-1, -1, -1))
                invert_ctrl_rotate.output >> ctrl_fix_r.rotate

                ctrl_cvs = ctrl.cv[:]
                for cv in ctrl_cvs:
                    pmc.move(cv, 0.5, moveZ=1, ws=1, wd=1, r=1)
                    pmc.move(cv, 0.1, moveY=1, ls=1, wd=1, r=1)

                jnt_ofs = pmc.duplicate(jnt, n=str(jnt).replace("_JNT", "_jnt_OFS"))[0]
                jnt_ofs.setAttr("drawStyle", 2)
                pmc.parent(jnt, jnt_ofs)

                ctrl.translate >> jnt.translate
                ctrl.rotate >> jnt.rotate
                ctrl.scale >> jnt.scale

                ctrls.append(ctrl)

                pmc.parent(jnt_ofs, self.parts_grp)
                pmc.parent(follicle, self.ctrl_input_grp)

            pmc.select(cl=1)
            pmc.skinCluster(ctrls_jnt, surface, bm=0, dr=4.0, mi=2, nw=1, sm=0, tsb=1, wd=0)

            return skn_jnts, surface, follicles, ctrls_jnt, ctrls_fol, ctrls
        else:
            pmc.error("faces aren't support yet")
Ejemplo n.º 29
0
def create_guideSurface(IdName, listOfJnts):
    loftCurves = []
    for i in range(2):
        # duplicate and select hierarchy of joints
        listOfOffsetJnts = pm.duplicate(listOfJnts,
                                        name='b_' + IdName + '_offset1',
                                        parentOnly=True)

        # offset each joint on it's own z-axis
        for jnt in listOfOffsetJnts:
            if i == 0:
                pm.move(jnt, (0, 0, -0.5),
                        relative=True,
                        objectSpace=True,
                        preserveChildPosition=True)
            if i == 1:
                pm.move(jnt, (0, 0, 0.5),
                        relative=True,
                        objectSpace=True,
                        preserveChildPosition=True)

        # draw loftcurves
        loftCurvePoints = []
        for each in listOfOffsetJnts:
            jntPosition = pm.xform(each, q=True, t=True, ws=True)
            loftCurvePoints.append(jntPosition)

        loftCurves.append(
            pm.curve(name=IdName + '_loftCurve' + str(i),
                     degree=1,
                     point=loftCurvePoints))
        pm.delete(listOfOffsetJnts)

    # loft guideSurface
    guideSurface = pm.loft(loftCurves[0],
                           loftCurves[1],
                           name=IdName + '_guide_surface',
                           ar=True,
                           rsn=True,
                           d=3,
                           ss=1,
                           object=True,
                           ch=False,
                           polygon=0)
    guideSurface = pm.rebuildSurface(guideSurface,
                                     ch=1,
                                     rpo=1,
                                     rt=0,
                                     end=1,
                                     kr=1,
                                     kcp=0,
                                     kc=0,
                                     su=0,
                                     du=3,
                                     sv=1,
                                     dv=3,
                                     tol=0.01,
                                     fr=0,
                                     dir=2)

    # cleanup
    pm.delete(loftCurves)
    guideSurface[0].inheritsTransform.set(False)
    guideSurface[0].overrideEnabled.set(True)
    guideSurface[0].overrideDisplayType.set(1)
    # guideSurface[0].visibility.set(False)

    print('Successfully lofted guide surface. Continuing...')
    return guideSurface
Ejemplo n.º 30
0
    def create_jnts(self):
        tentacle_jnts_crv = pmc.curve(d=1,
                                      p=[
                                          pmc.xform(self.guides[0],
                                                    q=1,
                                                    ws=1,
                                                    translation=1),
                                          pmc.xform(self.guides[1],
                                                    q=1,
                                                    ws=1,
                                                    translation=1)
                                      ],
                                      n="{0}_tentacle_curve_1".format(
                                          self.model.module_name))
        tentacle_jnts_rebuilded = pmc.rebuildCurve(tentacle_jnts_crv,
                                                   rpo=0,
                                                   rt=0,
                                                   end=1,
                                                   kr=0,
                                                   kep=1,
                                                   kt=0,
                                                   s=self.model.how_many_jnts,
                                                   d=1,
                                                   ch=0,
                                                   replaceOriginal=1)[0]
        if self.model.how_many_jnts == 2:
            pmc.delete(tentacle_jnts_rebuilded.cv[-2])
            pmc.delete(tentacle_jnts_rebuilded.cv[1])
        vertex_list = tentacle_jnts_rebuilded.cv[:]
        self.created_tentacle_jnts = rig_lib.create_jnts_from_cv_list_and_return_jnts_list(
            vertex_list, "{0}_tentacle".format(self.model.module_name))

        rig_lib.change_jnt_chain_suffix(self.created_tentacle_jnts,
                                        new_suffix="SKN")
        pmc.select(d=1)

        skin_selection = list(self.created_tentacle_jnts)

        for i, jnts in enumerate(self.created_tentacle_jnts):
            first_value = i
            second_value = float(((self.model.how_many_jnts)))
            default_value = float(first_value / second_value)
            jnts.addAttr("position",
                         attributeType="float",
                         defaultValue=default_value,
                         hidden=0,
                         keyable=1)

        pmc.select(d=1)

        tentacle_jnts_offset_name = str(self.created_tentacle_jnts[0]).replace(
            "_SKN", "_jnt_OFS")
        tentacle_jnts_offset = pmc.joint(
            p=pmc.xform(self.created_tentacle_jnts[0],
                        q=1,
                        ws=1,
                        translation=1),
            o=pmc.xform(self.created_tentacle_jnts[0], q=1, ws=1, rotation=1),
            n=tentacle_jnts_offset_name)

        pmc.parent(self.created_tentacle_jnts[0], tentacle_jnts_offset, r=0)
        pmc.parent(tentacle_jnts_offset, self.jnt_input_grp, r=0)

        tentacle_jnts_rebuilded.setAttr("translate", (0, 0, 0.1))
        tentacle_nurbs_crv_rebuilded = pmc.rebuildCurve(
            tentacle_jnts_rebuilded,
            rpo=0,
            rt=0,
            end=1,
            kr=0,
            kep=1,
            kt=0,
            s=self.model.how_many_jnts,
            d=3,
            ch=0,
            replaceOriginal=1)[0]
        tentacle_nurbs_crv = pmc.duplicate(tentacle_nurbs_crv_rebuilded,
                                           n="{0}_tentacle_curve_2".format(
                                               self.model.module_name))[0]
        tentacle_nurbs_crv.setAttr("translate", (0, 0, -0.1))

        tentacle_jnts_nurbs = pmc.loft(tentacle_nurbs_crv_rebuilded,
                                       tentacle_nurbs_crv,
                                       u=1,
                                       ar=1,
                                       ss=1,
                                       rn=0,
                                       po=0,
                                       rsn=1,
                                       d=1,
                                       c=0,
                                       n="{0}_variableFK_nurbs".format(
                                           self.model.module_name))

        pmc.delete(tentacle_nurbs_crv_rebuilded)
        pmc.delete(tentacle_nurbs_crv)

        pmc.select(d=1)

        pmc.skinCluster(skin_selection[0],
                        tentacle_jnts_nurbs[0],
                        sm=0,
                        nw=2,
                        mi=1,
                        rui=1,
                        dr=2,
                        n='VFK_SkinCluster')

        self.nurbs_tentacle = tentacle_jnts_nurbs

        pmc.select(d=1)
Ejemplo n.º 31
0
def main(size=0.5):

    pm.nurbsToPolygonsPref(polyType=1)
    pm.nurbsToPolygonsPref(format=2)
    pm.nurbsToPolygonsPref(uType=3)
    pm.nurbsToPolygonsPref(uNumber=1)
    pm.nurbsToPolygonsPref(vType=3)
    pm.nurbsToPolygonsPref(vNumber=1)

    mel.eval("""
    source "assignPfxToon.mel";
    """)
    sel_list = pm.ls(sl=1, ni=1)

    cam = getActiveCamera()

    for sel in sel_list:
        # NOTE 通过 Toon 创建轮廓
        mel.eval('assignPfxToon "" 0;')
        # NOTE 获取 Toon 节点
        profile_node = pm.ls(sl=1)[0]
        # NOTE 链接当前摄像机 外轮廓
        cam.t.connect(profile_node.cameraPoint, f=1)

        # NOTE 生成描边曲线
        base_crv_list = generateProfileCurve(profile_node)

        mesh_list = []
        inflate_crv_list = []
        # NOTE 曲线放样成描边模型
        for base in base_crv_list:
            pm.rebuildCurve(base,
                            ch=0,
                            rpo=1,
                            rt=0,
                            end=1,
                            kr=1,
                            kcp=0,
                            kep=1,
                            kt=0,
                            s=0,
                            d=3,
                            tol=0.01)
            inflate = inflateCurveOnMesh(base, sel, scale=size)
            inflate_crv_list.append(inflate)

            mesh = pm.loft(base,
                           inflate,
                           ch=0,
                           u=1,
                           c=0,
                           ar=1,
                           d=3,
                           ss=1,
                           rn=0,
                           po=1,
                           rsn=1)
            mesh_list.append(mesh)

        base_grp = pm.group(base_crv_list, n="base_grp")
        inflate_grp = pm.group(inflate_crv_list, n="inflate_grp")
        if len(mesh_list) > 2:
            pm.polyUnite(mesh_list, n="%s_profile" % sel, ch=0)
        # pm.delete(base_grp,inflate_grp)

        pm.delete(profile_node.getParent())
Ejemplo n.º 32
0
    def make(cls, start, end, name="soMuscle"):
        """Creates a new muscle positioned between start and end.

        start & end must both be locators.

        The locators are hijacked by the muscle and moved into its own special group.

        :param start: A locator describing where the muscle starts.
        :param end:   A locator describing where the muscle ends.
        :param name:  (optional) A descriptive name for the muscle (group.)
        """
        snode = pm.PyNode(start)
        if snode is None:
            raise ValueError("Couldn't deduce Maya type for start.")
        enode = pm.PyNode(end)
        if enode is None:
            raise ValueError("Couldn't dedude Maya type for end.")

        def findshape(n):
            if n.nodeType() == "transform":
                children = n.getChildren() # Can probably use n.getShape() here.
                if len(children) > 0:
                    return children[0], n
                else:
                    raise TypeError("Expected a locator or its transform node in start")
            elif n.nodeType() == "locator":
                return n, n.getParent()
            else:
                    raise TypeError("Expected a locator or its transform node in start")

        def getrottrans(trans):
            return trans.getRotation(space="world"), trans.getTranslation(space="world")

        # Find locator shapes, mostly to make sure they are locators.
        # Their transforms are needed though.
        snode, sloctrans = findshape(snode)
        enode, eloctrans = findshape(enode)

        mloctrans = pm.spaceLocator()
        # Point-constrain and orient constrain to other locators.
        pm.pointConstraint(sloctrans, eloctrans, mloctrans, maintainOffset=False)
        pm.orientConstraint(sloctrans, eloctrans, mloctrans)

        maingrp = pm.group(empty=True, name=name)
        maingrp.translate.lock(), maingrp.rotate.lock(), maingrp.scale.lock()

        grp = pm.group(empty=True, name="moveGroup")
        grp.setParent(maingrp)

        sloctrans.setParent(grp), sloctrans.rename("muscleStart")
        eloctrans.setParent(grp), eloctrans.rename("muscleEnd")
        mloctrans.setParent(grp), mloctrans.rename("muscleMid")

        # Make the locators smaller in the UI.
        for loctrans in [sloctrans, mloctrans, eloctrans]:
            loctrans.getShape().localScale.set(0.25, 0.25, 0.25)

        startdef = ("start", sloctrans) + getrottrans(sloctrans)
        enddef   = ("end", eloctrans) + getrottrans(eloctrans)
        middef   = ("mid", mloctrans) + getrottrans(mloctrans)

        circles = []
        for name, parent, rot, pos in [startdef, middef, enddef]:
            transform, _ = pm.circle(radius=0.1)
            pm.delete(transform, ch=True)
            circles.append(transform)
            transform.setParent(parent)
            # Change name AFTER we've parented them, so we can avoid naming collisions.
            transform.rename(name)
            transform.setRotation(rot)
            transform.setTranslation(pos, space="world")

        loftrans, _ = pm.loft(*circles)
        loftrans.setParent(maingrp) # Put in maingrp, so we avoid double transforms.
        loftrans.rename("muscleSurface")

        midcircle = circles[1]
        def addfloat3(obj, attrname):
            obj.addAttr(attrname, at="float3")
            for suffix in ["X", "Y", "Z"]:
                obj.addAttr(attrname + suffix, at="float", parent=attrname, k=True)

        addfloat3(midcircle, "startPos")
        addfloat3(midcircle, "endPos")
        maingrp.addAttr("bulgeFactor", at="float", defaultValue=1.0, minValue=0.01, maxValue=1000, k=True)

        sloctrans.translate >> midcircle.startPos
        eloctrans.translate >> midcircle.endPos

        # Some horrible MEL to preserve volume.
        expression = """
            vector $a = <<{0}.startPosX, {0}.startPosY, {0}.startPosZ>>;
            vector $b = <<{0}.endPosX,   {0}.endPosY,   {0}.endPosZ>>;

            float $len = `mag ($b - $a)`;
            $len += 0.0000001;
            float $f = {1}.bulgeFactor / $len;
            scaleX = $f;
            scaleY = $f;
        """.format(midcircle.name(), maingrp.name())

        pm.expression(o=midcircle, s=expression)