def create_nurbs(self):

        self.nurbs = pm.nurbsPlane(name='geo_' + self.ribbon_name,
                                   pivot=[0, 0, 0],
                                   axis=[0, 1, 0],
                                   width=1,
                                   lengthRatio=self.ribbon_segment,
                                   degree=3,
                                   ch=False)[0]
        self.nurbs.setRotation([0, 90, 0], space='world')
        pm.makeIdentity(self.nurbs, a=True, rotate=True)

        # rebuild nurbs to reduce CVs
        pm.rebuildSurface(self.nurbs,
                          replaceOriginal=True,
                          rebuildType=0,
                          endKnots=1,
                          keepRange=0,
                          keepControlPoints=0,
                          keepCorners=0,
                          spansU=1,
                          degreeU=1,
                          spansV=self.ribbon_segment,
                          degreeV=3,
                          ch=False)
Esempio n. 2
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
Esempio n. 3
0
def createRibbonSpine(*args):

	jointChainLen = int(jointChainLenField.getText())

	nurbsPlnName = nameField.getText() + '_ribbonPlane'
	nurbsPln = pm.nurbsPlane(u = 1, v = jointChainLen, lr = jointChainLen, n = nurbsPlnName, ax = [0,0,1])
	pm.rebuildSurface(nurbsPln, ch = 1, rpo = 1, end = 1, kr = 0, kc = 0, su =1, du = 1, sv = 5, dv = 3, tol = .01, dir = 0)
	pm.select(nurbsPln, r = True)

	mNurbsPln = pm.ls(selection = True)[0]
Esempio n. 4
0
    def build(self):
        # make the nurbs plane
        self.ribbonIkPlane = pm.nurbsPlane(
                axis = (0,0,1),
                degree = 3,    #cubic
                constructionHistory = False,
                name = self.name +'_'+d.PLANE,
                patchesU = 1,
                patchesV = self.numSpans,
                lengthRatio = self.numSpans)[0]
        pm.rebuildSurface(self.ribbonIkPlane, degreeU=1,
                          spansU=1, direction=0)
        u.makeNonRendering(self.ribbonIkPlane)
        pm.setAttr('%s.%s'% (self.ribbonIkPlane.name(),'visibility'), 0)
        pm.setAttr('%s.%s'% (self.ribbonIkPlane.name(),
                             'inheritsTransform'), 0)

        # move the pivots to the top of the plane
        self.ribbonIkPlane.setPivots((0,(self.numSpans/2.0),0))

        # place and scale the plane in 3d space
        pm.delete(pm.pointConstraint(self.startLoc,self.ribbonIkPlane))
        pm.delete(pm.orientConstraint(self.startLoc,self.ribbonIkPlane))
        #pm.delete(pm.aimConstraint(self.endLoc,self.ribbonIkPlane, 
        #            aimVector=(0,-1,0)))
                    #skip     =('x','z'))) 
        height = u.distance(self.startLoc, self.endLoc)
        scale  = (height / self.numSpans)
        self.ribbonIkPlane.scaleBy((scale,scale,scale))
        
        # create and attach follicles
        follicles = []
        for i in range(1,(self.numJoints+1)):
            follicle = self.createFollicle(
                    shape = self.ribbonIkPlane.getShape(),
                    posV = (i-1.0)/float(self.numJoints-1.0),
                    posU = 0.5, 
                    name = self.name + "_%s%02d" % (d.FOLLICLE,i))
            pm.setAttr(follicle.visibility, False)
            follicles.append(follicle)

        self.follicleGrp = pm.group(follicles, name='%s_%s_grp' % \
                                    (self.name,d.FOLLICLE))
        pm.setAttr('%s.%s'% (self.follicleGrp,'inheritsTransform'),0)
        
        # create the bind joints
        for i,f in enumerate(follicles):
            self.bindJoints.append(u.placeJoint(
                position = u.getWsLocation(f),
                name = '%s%s%02d_%s'%(self.name, d.JOINT.title(),
                                      i+1, self.jointPostfix),
                parent = f))

        # parent
        self.ribbonIkPlane.setParent(self.parent)
Esempio n. 5
0
    def point_base(self, *points, **kwargs):
        super(Loft, self).point_base(*points, **kwargs)
        delete_history = kwargs.pop('delete_history', True)
        self.path = self.curve_creator.point_base(*pm.ls(points), ep=True)

        self._create_profile(**kwargs)

        original_surf = pm.extrude(self.profile, self.path, fixedPath=True,
                                   useComponentPivot=1, useProfileNormal=True)

        swap_uv = pm.rebuildSurface(original_surf[0], keepControlPoints=True, rebuildType=0,
                                    keepRange=0)

        new_surface = pm.reverseSurface(swap_uv[0], direction=3)
        self.skin_surface = new_surface[0]
        self.name_convention.rename_name_in_format(self.skin_surface, name='extrude')

        cps = pm.createNode('closestPointOnSurface')
        measure_locator = self.locator_creator.point_base(points[0])
        measure_locator.worldPosition >> cps.inPosition
        self.skin_surface.worldSpace[0] >> cps.inputSurface
        u_closer_value = cps.parameterU.get()
        pm.delete(measure_locator, cps)

        if u_closer_value > .5:
            new_surface = pm.reverseSurface(self.skin_surface, direction=0)
            self.skin_surface = new_surface[0]

        if delete_history:
            self.delete_history()
        return self.skin_surface
Esempio n. 6
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)
Esempio n. 7
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
Esempio n. 8
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)
Esempio n. 9
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)
Esempio n. 10
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)
Esempio n. 11
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)
Esempio 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)
Esempio n. 13
0
 def build_nurbs_between_points(xformA, xformB, ref_xform, spansUV=[1,4]):
     """ Build a simple nurbs surface between two points with a surface up third object
     Args:
         xformA (pm.nt.Transform): first point
         xformB (pm.nt.Transform): second point
         ref_xform (pm.nt.Transform): aim object
     Usage:
         Mesh.build_nurbs_between_points(pm.PyNode('locator1'),pm.PyNode('locator2'),pm.PyNode('locator3'))
     """
     nurbs = pm.nurbsPlane(p=[0,0,0], ax=[0,1,0], w=1, lr=1, d=1, u=1, v=1, ch=0)[0]
     nurbs.scalePivot.set(0,0,0.5)
     nurbs.rotatePivot.set(0,0,0.5)
     
     pm.delete(pm.pointConstraint(xformA, nurbs, mo=False))
     pm.delete(pm.aimConstraint(xformB, nurbs, worldUpType=1, aimVector=[0,0,-1], worldUpVector=[0,1,0], worldUpObject=ref_xform, mo=False))
     
     cluster = pm.cluster(nurbs.getShape().cv[0:1][1])
     pm.delete(pm.pointConstraint(xformB, cluster, mo=False))
     pm.delete(nurbs, ch=True)
     u, v = spansUV
     pm.rebuildSurface(nurbs.getShape(), ch=False, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=u, du=3, sv=v, dv=3, tol=0, fr=0, dir=2)
     return nurbs
Esempio n. 14
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)
Esempio n. 15
0
    def createCtrls(self):
        ctrlList = []
        # rebuildSurface -ch 1 -rpo 1 -rt 0 -end 1 -kr 0 -kcp 0 -kc 0 -su 4 -du 3 -sv 1 -dv 3 -tol 0 -fr 0  -dir 2 "Tail_srf";
        self.rbnSrf = \
        pm.rebuildSurface(self.rbnSrf.name(), ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=(self.numCtrl - 1), du=3,
                          sv=1, dv=3, tol=0, fr=0, dir=2)[0]

        pociNode = pm.shadingNode('pointOnCurveInfo', asUtility=1)
        pociNode.turnOnPercentage.set(1)
        pm.ls(self.ikCrv)[0].getShape().worldSpace[0] >> pociNode.inputCurve
        tempLoc = pm.spaceLocator()
        pociNode.position >> tempLoc.translate

        segmentLength = 1.0 / (self.numCtrl - 1)

        for i in range(self.numCtrl):
            pociNode.parameter.set(i * segmentLength)
            pos = tempLoc.getTranslation(space='world')

            ctrl = self.addCtrl(i)
            self.ctrlList.append(ctrl)
            ctrlMainGrp = self.getCtrlMainGrp(ctrl)
            ctrlMainGrp.setTranslation(pos)
            pm.parent(ctrlMainGrp, self.allCtrlGrp)

            pm.addAttr(ctrl,
                       longName='extras',
                       nn='------',
                       attributeType='enum',
                       en='Extras:',
                       keyable=True)
            pm.setAttr(ctrl.name() + '.extras', lock=1)
            pm.addAttr(ctrl,
                       longName='scaleRadius',
                       attributeType='float',
                       keyable=True,
                       min=0.0001,
                       defaultValue=0.3)

        pm.parent(self.allCtrlGrp, self.mainGrp)
Esempio n. 16
0
    def curve_base(self, *path, **kwargs):
        swap_uv = kwargs.pop('swap_uv', True)
        delete_history = kwargs.pop('delete_history', False)
        self.path = path[0]
        self._create_profile(**kwargs)
        print self.profile

        original_surf = pm.extrude(self.profile, self.path, fixedPath=True,
                                   useComponentPivot=1, useProfileNormal=True)
        if swap_uv:
            swap_uv_curve = pm.rebuildSurface(original_surf[0], keepControlPoints=True, rebuildType=0, keepRange=0)
            new_surface = pm.reverseSurface(swap_uv_curve[0], direction=3)
            self.skin_surface = new_surface[0]
        else:
            self.skin_surface = original_surf

        self.name_convention.rename_name_in_format(self.skin_surface, name='extrude')

        if delete_history:
            self.delete_history()

        return self.skin_surface
Esempio n. 17
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)
Esempio n. 18
0
    def construction(self):
        
        self.folList = []
        
        #create burbs plane
        ribbonGeo = pm.nurbsPlane(p = (0,0,0),ax = (0,1,0),w = self.Width,lr = self.Length,
                                  d = 3,u = self.UVal,v = self.segment,ch = 1,n = (self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_'))

        #rebuild ribbon geo
        if self.VVal > self.UVal:
            pm.rebuildSurface(ribbonGeo[0],ch = 1,rpo = 1,rt = 0,end = 1,kr = 0,kcp = 0,kc = 0,su = self.UVal,du = 1,sv = self.VVal,dv = 3,tol = 0.000155,fr = 0,dir = 2)
            
        if self.UVal > self.VVal:
            pm.rebuildSurface(ribbonGeo[0],ch = 1,rpo = 1,rt = 0,end = 1,kr = 0,kcp = 0,kc = 0,su = self.UVal,du = 3,sv = self.VVal,dv = 1,tol = 0.000155,fr = 0,dir = 2)
        
        #clear history of ribbonGeometry
        pm.select(ribbonGeo[0],r = 1)
        pm.delete(ch = 1)
        
        #CREATE THE HAIR FOLLICLES
        self.folGrp = pm.group(em = 1,n = getUniqueName(self.side,self.RibbonName + 'Fol','grp')) 
        
        for fol in range(self.segment):
            
            #createNodeName
            follicleTransName = getUniqueName(self.side,self.RibbonName,'fol')
            follicleShapeName = getUniqueName(self.side,self.RibbonName,'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] + '.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 + '.parameterU'), 0.5)
            pm.setAttr((follicleShape + '.parameterV'), float(1.0 / self.segment) * fol + (1.0 / (self.segment * 2)))
            
            #Lock the translate/rotate of the follicle
            pm.setAttr((follicleTrans + '.translate'), lock=True)
            pm.setAttr((follicleTrans + '.rotate'), lock=True)
            
            #parent
            self.folList.append(follicleTrans)
            follicleTrans.setParent(self.folGrp)

        #CREATE JOINTS SNAPPED AND PARENTED TO THE FOLLICLE---
        for num,fol in enumerate(self.folList):
            jJoint = pm.joint(n = self.side + '_' + self.RibbonName + '_Rbbn0' + str(num) + '_jj',p = (0,0,0),rad = min(self.Width,self.Length) * .25)
            pm.parent(jJoint,fol)
            jJoint.translate.set(0,0,0)
            self.jj.append(jJoint)
             
        #CREATE SOME TEMPORARY CLUSTERS TO PLACE THE POS LOCATORS---
        if self.UVal > self.VVal:
            vNo = self.UVal + 2
            pm.select(self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_.cv[' + str(vNo) + '][0:1]',r = 1)
            startCls =  pm.cluster(n = 'spCltr')
            pm.select(self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_.cv[0][0:1]',r = 1)
            endCls = pm.cluster(n = 'epCltr')
             
        if self.VVal > self.UVal:
            vNo = self.VVal + 2
            pm.select(self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_.cv[0:1][' + str(vNo) + ']',r = 1)
            startCls = pm.cluster(n = 'spCltr')
            pm.select(self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_.cv[0:1][0]',r = 1)
            endCls = pm.cluster(n = 'epCltr')                
             
        #CREATE SOME LOCATORS---
        #CREATE START POINT LOCATORS AND PARENT THEM PROPERLY---
        spLocPos = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnSp01_pos')
        spLocAim = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnSp01_aim')
        self.startUploc = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnSp01_up')
         
        #hide shape
#         spLocPos.getShape().v.set(0)
#         spLocAim.getShape().v.set(0)
#         spLocUp.getShape().v.set(0)
         
        self.startLoc = spLocPos
         
        pm.parent(spLocAim,spLocPos)
        pm.parent(self.startUploc,spLocPos)
         
        #CREATE MID POINT LOCATORS AND PARENT THEM PROPERLY---
        mpLocPos = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnMp01_pos')
        self.mpLocAim = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnMp01_aim')
        mpLocUp = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnMp01_up')
         
        #hide shape
#         mpLocPos.getShape().v.set(0)
#         self.mpLocAim.getShape().v.set(0)
#         mpLocUp.getShape().v.set(0)
         
        self.midloc = mpLocPos
         
        pm.parent(self.mpLocAim,mpLocPos)
        pm.parent(mpLocUp,mpLocPos)   
         
        #CREATE END POINT LOCATORS AND PARENT THEM PROPERLY---
        epLocPos = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnEp01_pos')
        epLocAim = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnEp01_aim')
        self.epUploc = pm.spaceLocator(p = (0,0,0), n = self.side + '_' + self.RibbonName + '_RbbnEp01_up')
         
        #hide shape
#         epLocPos.getShape().v.set(0)
#         epLocAim.getShape().v.set(0)
#         self.epUploc.getShape().v.set(0)
         
        self.endLoc = epLocPos
         
        pm.parent(epLocAim,epLocPos)
        pm.parent(self.epUploc,epLocPos)     
         
        #CONSTRAINT EACH LOCATORS PROPERLY---                                                   
        pm.pointConstraint('spCltrHandle',spLocPos,o = (0,0,0),w = 1)                                    
        pm.delete(self.side + '_' + self.RibbonName + '_RbbnSp01_pos_pointConstraint1')
         
        pm.pointConstraint('epCltrHandle',epLocPos,o = (0,0,0),w = 1)                                    
        pm.delete(self.side + '_' + self.RibbonName + '_RbbnEp01_pos_pointConstraint1')
         
        pm.pointConstraint(spLocPos,epLocPos,mpLocPos,o = (0,0,0),w = 1)    
        pm.pointConstraint(self.startUploc,self.epUploc,mpLocUp,o = (0,0,0),w = 1)
     
        #OFFSET THE POSITION OF THE UP LOCATOR---
      
        pm.setAttr(self.startUploc.ty,min(self.Width,self.Length) * .5)
        pm.setAttr(self.epUploc.ty,min(self.Width,self.Length) * .5)       
         
        #CREATE CTRL JOINTS
        pm.select(cl = 1)
        tx = tz = 0.0
        if self.VVal > self.UVal:
            tz = self.Length * .2
             
        if self.UVal > self.VVal:
            tx = self.Width * .2    
             
        #############   
         
        #transmit Jc joint info---
        #FOR START POINT JOINT---
        self.startJc = pm.joint(p = (0,0,0),rad = min(self.Width,self.Length) * .5,n = self.side + '_' + self.RibbonName + '_RbbnSp01_jc')
        pm.joint(p = (tx * .6,0,tz * .6),rad = min(self.Width,self.Length) * .5,n = self.side + '_' + self.RibbonName + '_RbbnSp02_jc')
        pm.joint(e = 1,zso = 1,oj = 'xyz',sao = 'yup',n = self.side + '_' + self.RibbonName + '_RbbnSp02_jc')
         
        #FOR MIDDLE POINT JOINT---
        pm.select(cl = 1)
        self.midJc = pm.joint(p = (0,0,0),rad = min(self.Width,self.Length) * .5,n = self.side + '_' + self.RibbonName + '_RbbnMp01_jc')
        pm.joint(e = 1,zso = 1,oj = 'xyz',sao = 'yup',n = self.side + '_' + self.RibbonName + '_RbbnMp01_jc')
         
        #FOR END POINT JOINT---
        pm.select(cl = 1)
        self.endJc = pm.joint(p = (0,0,0),rad = min(self.Width,self.Length) * .5,n = self.side + '_' + self.RibbonName + '_RbbnEp01_jc')
        pm.joint(p = (tx * -0.6,0,tz * -0.6),rad = min(self.Width,self.Length) * .5,n = self.side + '_' + self.RibbonName + '_RbbnEp02_jc')
        pm.joint(e = 1,zso = 1,oj = 'xyz',sao = 'yup',n = self.side + '_' + self.RibbonName + '_RbbnEp02_jc')  
     
        #PARENT THE CONTROL JOINTS APPROPRIATLY---     
        pm.parent(self.side + '_' + self.RibbonName + "_RbbnSp01_jc",spLocAim,r = 1)
        pm.parent(self.side + '_' + self.RibbonName + "_RbbnMp01_jc",self.mpLocAim,r = 1)
        pm.parent(self.side + '_' + self.RibbonName + "_RbbnEp01_jc",epLocAim,r = 1)
         
        #APPLY THE AIM CONSTRINTS---
        aTz = 0
        if self.VVal > self.UVal:
            aTz = 1
             
        aTx = 0
        if self.UVal > self.VVal:
            aTx = 1
         
        #FOR MIDDLE POINT---
        pm.aimConstraint(self.side + '_' + self.RibbonName + "_RbbnSp01_pos",self.side + '_' + self.RibbonName + "_RbbnMp01_aim",o = (0,0,0),w = 1,aim = (aTx * -1,0,aTz *  -1),u = (0,1,0),wut = 'object',wuo = self.side + '_' + self.RibbonName + '_RbbnMp01_up')
        #FOR START POINT---
        pm.aimConstraint(self.side + '_' + self.RibbonName + "_RbbnMp01_jc",self.side + '_' + self.RibbonName + "_RbbnSp01_aim",o = (0,0,0),w = 1,aim = (aTx,0,aTz),u = (0,1,0),wut = 'object',wuo = self.side + '_' + self.RibbonName + '_RbbnSp01_up')
        #FOR END POINT---
        pm.aimConstraint(self.side + '_' + self.RibbonName + "_RbbnMp01_jc",self.side + '_' + self.RibbonName + "_RbbnEp01_aim",o = (0,0,0),w = 1,aim = (aTx * -1,0,aTz *  -1),u = (0,1,0),wut = 'object',wuo = self.side + '_' + self.RibbonName + '_RbbnEp01_up')
             
        #APPLY SKINCLUSTER---
        pm.select(cl = 1)
        pm.skinCluster(self.side + '_' + self.RibbonName + "_RbbnSp01_jc",self.side + '_' + self.RibbonName + "_RbbnMp01_jc",self.side + '_' + self.RibbonName + "_RbbnEp01_jc",self.side + '_' + self.RibbonName + "_Rbbn01_geo_01_",tsb = 1,ih = 1,mi = 3,dr = 4,rui = 1)
         
        #CLEAN UP
        pm.delete(startCls)
        pm.delete(endCls)
        pm.rename(self.side + '_' + self.RibbonName + '_Rbbn01_geo_01_',self.side + '_' + self.RibbonName + '_Rbbn01_geo_01')  
         
        #GROUP THEM ALL
        self.main = pm.group(self.folGrp,self.side + '_' + self.RibbonName + '_Rbbn01_geo_01',self.side + '_' + self.RibbonName + '_RbbnSp01_pos',self.side + '_' + self.RibbonName + '_RbbnMp01_pos',self.side + '_' + self.RibbonName + '_RbbnEp01_pos',n = self.side + '_' + self.RibbonName + "_Rbbn01_grp")
        pm.xform(os = 1,piv = (0,0,0))
         
        if self.subMid == 1:
            self.__midCC()
Esempio n. 19
0
    def doRig(self):
        p1 = pm.xform(self.guide1, q=1, t=1)
        p2 = pm.xform(self.guide2, q=1, t=1)
        p3 = pm.xform(self.guide3, q=1, t=1)

        A = om.MVector(p1)
        B = om.MVector(p2)
        C = om.MVector(p3)

        AC = A - C
        nurbsLength = AC.length()

        # setup do nurbs plane e follicles
        nurbs = pm.nurbsPlane(w=nurbsLength / self.sections,
                              lr=self.sections,
                              v=self.sections)[0]
        nurbsShp = nurbs.getShape()
        pm.rebuildSurface(nurbs,
                          ch=1,
                          rpo=1,
                          rt=0,
                          end=1,
                          kr=0,
                          kcp=0,
                          kc=0,
                          su=1,
                          du=1,
                          dv=3,
                          tol=0.01,
                          fr=0,
                          dir=0)

        pm.xform(nurbs, t=p1, ws=True)

        guide2Up = pm.duplicate(self.guide2, n=self.guide2 + '_up')[0]
        pm.delete(pm.pointConstraint(self.guide1, self.guide3, guide2Up))
        pm.xform(guide2Up,
                 r=True,
                 t=(self.direction[0], self.direction[1], self.direction[2]))
        pm.delete(
            pm.aimConstraint(self.guide3,
                             nurbs,
                             w=1,
                             o=(0, 0, 0),
                             aim=(0, 1, 0),
                             u=(-1, 0, 0),
                             wut='object',
                             wuo=guide2Up))
        pm.delete(guide2Up)
        pm.delete(pm.pointConstraint(self.guide1, self.guide3, nurbs))

        grpFol = pm.group(em=1, n=self.name + 'Foll_grp')
        grpScale = pm.group(em=1, n=self.name + 'Scale_grp')
        vValue = 0
        vSections = 1.0 / self.sections
        vOffset = vSections / 2
        id = 0

        # medindo o comprimento do nurbs para o squash stretch
        arcLengthShp = pm.createNode('arcLengthDimension')
        arcLength = arcLengthShp.getParent()
        nurbsShp.worldSpace[0] >> arcLengthShp.nurbsGeometry
        arcLengthShp.vParamValue.set(1)
        arcLengthShp.uParamValue.set(0)
        arcLenValue = arcLengthShp.arcLengthInV.get()
        autoManualList = []
        factorList = []
        on_offList = []
        skinJntsList = []

        for follicle in range(self.sections):
            id += 1
            # criando nodes para o stretch squash
            normalizeTo0 = pm.createNode('plusMinusAverage',
                                         n=self.name + 'RbbnNormalize0' +
                                         ` id ` + '_pma')
            scaleAux = pm.createNode('multiplyDivide',
                                     n=self.name + 'RbbnScaleAux0' + ` id ` +
                                     '_md')
            factor = pm.createNode('multiplyDivide',
                                   n=self.name + 'RbbnFactor0' + ` id ` +
                                   '_md')
            on_off = pm.createNode('multiplyDivide',
                                   n=self.name + 'RbbnOnOff0' + ` id ` + '_md')
            autoManual = pm.createNode('plusMinusAverage',
                                       n=self.name + 'RbbnAutoManual0' +
                                       ` id ` + '_pma')
            autoReverse = pm.createNode('reverse',
                                        n=self.name + 'RbbnReverse0' + ` id ` +
                                        '_rev')

            # ajustando valores dos nodes de stretch squash
            normalizeTo0.operation.set(2)
            scaleAux.input2.set((arcLenValue, arcLenValue, arcLenValue))

            # conectando os nodes de stretch squash
            arcLength.arcLengthInV >> normalizeTo0.input3D[0].input3Dx
            arcLength.arcLengthInV >> normalizeTo0.input3D[0].input3Dy
            arcLength.arcLengthInV >> normalizeTo0.input3D[0].input3Dz

            scaleAux.output >> normalizeTo0.input3D[1]
            grpScale.scale >> scaleAux.input1
            normalizeTo0.output3D >> factor.input2
            factor.output >> on_off.input1
            on_off.output >> autoReverse.input
            autoReverse.output >> autoManual.input3D[0]

            # criando nodes do rbbn
            folShp = pm.createNode('follicle')
            fol = folShp.getParent()

            # escondendo os follicles
            if self.visibility == 0:
                folShp.visibility.set(0)

            jnt = pm.joint(radius=nurbsLength * 0.2)
            skinJntsList.append(jnt)

            # conectando e ajustando nodes do rbbn
            autoManual.output3Dx >> jnt.scaleX
            autoManual.output3Dz >> jnt.scaleZ
            nurbsShp.local >> folShp.inputSurface
            nurbsShp.worldMatrix[0] >> folShp.inputWorldMatrix
            folShp.outRotate >> fol.rotate
            folShp.outTranslate >> fol.translate
            folShp.parameterU.set(0.5)
            vValue += vSections
            folShp.parameterV.set(vValue - vOffset)
            pm.parent(fol, grpFol)

            pm.scaleConstraint(grpScale, fol, mo=1)

            # listas para loops posteriores
            on_offList.append(on_off)
            factorList.append(factor)
            autoManualList.append(autoManual)

        # fk setup
        FKSIZE = (nurbsLength / 2) / self.sections

        topPosLoc = pm.spaceLocator()
        topAimLoc = pm.spaceLocator()
        topAimLoc.setParent(topPosLoc)

        topToSkin = pm.joint(
            radius=nurbsLength * 0.2,
            p=(0, 0, 0),
        )
        pm.joint(
            radius=nurbsLength * 0.15,
            p=(0, -FKSIZE, 0),
        )
        topUpLoc = pm.spaceLocator()
        topUpLoc.setParent(topPosLoc)

        pm.move(FKSIZE * 3 * self.upVector[0], FKSIZE * 3 * self.upVector[1],
                FKSIZE * 3 * self.upVector[2], topUpLoc)
        pm.delete(pm.pointConstraint(self.guide3, topPosLoc))
        # pm.delete(pm.parentConstraint(guide3,topPosLoc))

        midPosLoc = pm.spaceLocator()
        midAimLoc = pm.spaceLocator()
        midAimLoc.setParent(midPosLoc)

        midOffLoc = pm.spaceLocator()
        midOffLoc.setParent(midAimLoc)

        midToSkin = pm.joint(radius=nurbsLength * 0.2, p=(0, 0, 0))
        midUpLoc = pm.spaceLocator()
        midUpLoc.setParent(midPosLoc)

        pm.move(FKSIZE * 3 * self.upVector[0], FKSIZE * 3 * self.upVector[1],
                FKSIZE * 3 * self.upVector[2], midUpLoc)

        lwrPosLoc = pm.spaceLocator()
        lwrAimLoc = pm.spaceLocator()
        lwrAimLoc.setParent(lwrPosLoc)

        lwrToSkin = pm.joint(radius=nurbsLength * 0.2, p=(0, 0, 0))
        pm.joint(radius=nurbsLength * 0.15, p=(0, FKSIZE, 0))

        lwrUpLoc = pm.spaceLocator()
        lwrUpLoc.setParent(lwrPosLoc)

        pm.move(FKSIZE * 3 * self.upVector[0], FKSIZE * 3 * self.upVector[1],
                FKSIZE * 3 * self.upVector[2], lwrUpLoc)
        pm.delete(pm.pointConstraint(self.guide1, lwrPosLoc))

        topPosLocShp = topPosLoc.getShape()
        midPosLocShp = midPosLoc.getShape()
        lwrPosLocShp = lwrPosLoc.getShape()
        topAimLocShp = topAimLoc.getShape()
        midAimLocShp = midAimLoc.getShape()
        lwrAimLocShp = lwrAimLoc.getShape()
        topUpLocShp = topUpLoc.getShape()
        midUpLocShp = midUpLoc.getShape()
        lwrUpLocShp = lwrUpLoc.getShape()
        midOffLocShp = midOffLoc.getShape()

        topPosLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        topAimLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        topUpLocShp.localScale.set(
            (nurbsLength * 0.05, nurbsLength * 0.05, nurbsLength * 0.05))
        midPosLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        midAimLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        midUpLocShp.localScale.set(
            (nurbsLength * 0.05, nurbsLength * 0.05, nurbsLength * 0.05))
        midOffLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        lwrPosLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        lwrAimLocShp.localScale.set(
            (nurbsLength * 0.2, nurbsLength * 0.2, nurbsLength * 0.2))
        lwrUpLocShp.localScale.set(
            (nurbsLength * 0.05, nurbsLength * 0.05, nurbsLength * 0.05))

        pm.parent(topPosLoc, midPosLoc, lwrPosLoc, grpScale)

        # criando constraints para os locators do rbbn
        pm.aimConstraint(midToSkin,
                         topAimLoc,
                         aim=(0, -1, 0),
                         u=(1, 0, 0),
                         wut='object',
                         wuo=topUpLoc)
        pm.aimConstraint(midToSkin,
                         lwrAimLoc,
                         aim=(0, 1, 0),
                         u=(1, 0, 0),
                         wut='object',
                         wuo=lwrUpLoc)
        pm.aimConstraint(topPosLoc,
                         midAimLoc,
                         aim=(0, 1, 0),
                         u=(1, 0, 0),
                         wut='object',
                         wuo=midUpLoc)

        pm.pointConstraint(topPosLoc, lwrPosLoc, midPosLoc)
        pm.pointConstraint(topUpLoc, lwrUpLoc, midUpLoc)

        # skin setup

        skin = pm.skinCluster(topToSkin, midToSkin, lwrToSkin, nurbs, tsb=1)
        if self.sections == 3:
            pm.skinPercent(skin, nurbs + '.cv[0:1][5]', tv=(topToSkin, 1))
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][4]',
                           tv=[(topToSkin, 0.6), (midToSkin, 0.4)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][3]',
                           tv=[(topToSkin, 0.2), (midToSkin, 0.8)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][2]',
                           tv=[(topToSkin, 0.2), (midToSkin, 0.8)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][1]',
                           tv=[(topToSkin, 0.6), (midToSkin, 0.4)])
            pm.skinPercent(skin, nurbs + '.cv[0:1][0]', tv=(topToSkin, 1))

        elif self.sections == 5:
            pm.skinPercent(skin, nurbs + '.cv[0:1][7]', tv=(topToSkin, 1))
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][6]',
                           tv=[(topToSkin, 0.80), (midToSkin, 0.2)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][5]',
                           tv=[(topToSkin, 0.5), (midToSkin, 0.5)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][4]',
                           tv=[(topToSkin, 0.25), (midToSkin, 0.75)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][3]',
                           tv=[(lwrToSkin, 0.25), (midToSkin, 0.75)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][2]',
                           tv=[(lwrToSkin, 0.5), (midToSkin, 0.5)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][1]',
                           tv=[(lwrToSkin, 0.8), (midToSkin, 0.2)])
            pm.skinPercent(skin, nurbs + '.cv[0:1][0]', tv=(lwrToSkin, 1))

        elif self.sections == 7:
            pm.skinPercent(skin, nurbs + '.cv[0:1][9]', tv=(topToSkin, 1))
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][8]',
                           tv=[(topToSkin, 0.85), (midToSkin, 0.15)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][7]',
                           tv=[(topToSkin, 0.6), (midToSkin, 0.4)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][6]',
                           tv=[(topToSkin, 0.35), (midToSkin, 0.65)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][5]',
                           tv=[(topToSkin, 0.25), (midToSkin, 0.75)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][4]',
                           tv=[(lwrToSkin, 0.25), (midToSkin, 0.75)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][3]',
                           tv=[(lwrToSkin, 0.35), (midToSkin, 0.65)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][2]',
                           tv=[(lwrToSkin, 0.6), (midToSkin, 0.4)])
            pm.skinPercent(skin,
                           nurbs + '.cv[0:1][1]',
                           tv=[(lwrToSkin, 0.85), (midToSkin, 0.15)])
            pm.skinPercent(skin, nurbs + '.cv[0:1][0]', tv=(lwrToSkin, 1))
        else:
            print "!!!There's skinning support for 3,5 and 7 sections only!!!"

        # posicionando o controle do meio
        pm.delete(pm.pointConstraint(self.guide2, midOffLoc))

        # criando controles
        if self.createCtrls == 0:
            topCircle = pm.circle(r=nurbsLength * .2,
                                  nr=(self.ctrlNormal[0], self.ctrlNormal[1],
                                      self.ctrlNormal[2]))
            topCtrlGrp = pm.group()
            topCtrlGrp.setParent(grpScale)
            pm.delete(pm.parentConstraint(self.guide3, topCtrlGrp, mo=0))
            pm.parentConstraint(topCircle[0], topPosLoc)

            midCircle = pm.circle(r=nurbsLength * .2,
                                  nr=(self.ctrlNormal[0], self.ctrlNormal[1],
                                      self.ctrlNormal[2]))
            midCtrlGrp = pm.group()
            midCtrlGrp.setParent(midOffLoc)
            pm.delete(pm.parentConstraint(midToSkin, midCtrlGrp))
            midJointZerado = self.zeroOut(midToSkin, returnGrpName=1)[0]
            pm.parent(midJointZerado, grpScale)
            pm.parentConstraint(midCircle[0], midJointZerado, mo=1)

            lwrCircle = pm.circle(r=nurbsLength * .2,
                                  nr=(self.ctrlNormal[0], self.ctrlNormal[1],
                                      self.ctrlNormal[2]))
            lwrCtrlGrp = pm.parent(pm.group(), grpScale)
            pm.delete(pm.parentConstraint(self.guide1, lwrCtrlGrp, mo=0))
            pm.parentConstraint(lwrCircle[0], lwrPosLoc)
        else:
            midCircle = pm.circle(r=nurbsLength * .2,
                                  nr=(self.ctrlNormal[0], self.ctrlNormal[1],
                                      self.ctrlNormal[2]))
            midCtrlGrp = pm.parent(pm.group(), midOffLoc)
            pm.delete(pm.parentConstraint(midToSkin, midCtrlGrp))
            midJointZerado = self.zeroOut(midToSkin, returnGrpName=1)[0]
            pm.parent(midJointZerado, grpScale)
            pm.parentConstraint(midCircle[0], midJointZerado, mo=1)

        id = 0

        midCircle[0].addAttr('autoSS', k=1, dv=0.0, at='double', min=0, max=1)
        midCircleShp = midCircle[0].getShape()

        if self.createCtrls:
            midCircleShp.v.set(0)

        for autoManualAuxNodes in autoManualList:
            id += 1
            # criando e ajustando nodes para stretch squash
            manualNormalize = pm.createNode(
                'plusMinusAverage',
                n=self.name + 'RbbnManualNormalize0' + str(id) + '_pma')
            manualFactor = pm.createNode('multiplyDivide',
                                         n=self.name + 'RbbnManualFactor0' +
                                         str(id) + '_md')
            ratioScale = pm.createNode('multiplyDivide',
                                       n=self.name + 'RbbnRatioScale0' +
                                       str(id) + 'md')
            zRatio = pm.createNode('multiplyDivide',
                                   n=self.name + 'RbbnSsManualZratio' +
                                   str(id) + '_md')

            manualFactor.output >> autoManualAuxNodes.input3D[1]
            midCircle[0].scale >> manualNormalize.input3D[0]
            manualNormalize.output3D >> manualFactor.input2

            manualNormalize.operation.set(2)
            manualNormalize.input3D[1].input3D.set((1, 1, 1))
            ratioScale.operation.set(2)

            # adicionando atributos de squash
            midCircleShp.addAttr('manualFactorX0' + str(id),
                                 k=1,
                                 at='float',
                                 dv=1)
            midCircleShp.addAttr('manualRatioZ0' + str(id), k=1, at='float')
            midCircleShp.addAttr('autoFactorX0' + str(id), k=1, at='float')
            midCircleShp.addAttr('autoRatioZ0' + str(id), k=1, at='float')

            # conectando os atributos acima
            midCircleShp.attr('manualRatioZ0' + str(id)) >> zRatio.input1Z
            midCircleShp.attr('autoRatioZ0' + str(id)) >> zRatio.input1X

            midCircle[0].autoSS >> on_offList[id - 1].input2X  # on_off
            midCircle[0].autoSS >> on_offList[id - 1].input2Z  # on_off
            midCircleShp.attr('manualFactorX0' +
                              str(id)) >> manualFactor.input1X
            midCircleShp.attr('manualFactorX0' + str(id)) >> zRatio.input2Z
            ratioScale.outputX >> zRatio.input2X
            zRatio.outputZ >> manualFactor.input1Z
            ratioScale.outputX >> factorList[id - 1].input1X  # factor
            zRatio.outputX >> factorList[id - 1].input1Z  # factor
            grpScale.scale >> ratioScale.input2
            midCircleShp.attr('autoFactorX0' + str(id)) >> ratioScale.input1X

            # ajustando os atributos
            midCircleShp.attr('manualRatioZ0' + str(id)).set(1)
            midCircleShp.attr('autoRatioZ0' + str(id)).set(1)

        # ajustando valores iniciais para os factores de squash

        if self.sections == 3:
            midCircleShp.autoFactorX02.set(0.08)
        elif self.sections == 5:
            midCircleShp.autoFactorX01.set(0.02)
            midCircleShp.autoFactorX02.set(0.25)
            midCircleShp.autoFactorX03.set(0.22)
            midCircleShp.autoFactorX04.set(0.25)
            midCircleShp.autoFactorX05.set(0.02)
        elif self.sections == 7:
            midCircleShp.autoFactorX01.set(0)
            midCircleShp.autoFactorX02.set(0.11)
            midCircleShp.autoFactorX03.set(0.1)
            midCircleShp.autoFactorX04.set(0.16)
            midCircleShp.autoFactorX05.set(0.1)
            midCircleShp.autoFactorX06.set(0.11)
            midCircleShp.autoFactorX07.set(0)

        # toggles displays
        if self.visibility == 0:
            pm.toggle(nurbs, g=1, te=1)
            pm.toggle(arcLength, te=1)
            arcLength.visibility.set(0)
            topPosLoc.visibility.set(0)
            midPosLocShp = midPosLoc.getShape()
            midPosLocShp.visibility.set(0)
            midAimLocShp = midAimLoc.getShape()
            midAimLocShp.visibility.set(0)
            midOffLocShp = midOffLoc.getShape()
            midOffLocShp.visibility.set(0)
            lwrPosLoc.visibility.set(0)
            midUpLoc.visibility.set(0)
            grpScale.visibility.set(0)
            grpFol.visibility.set(0)

        # agrupando tudo
        finalRbbnGrp = pm.group(em=1, n=self.name + 'finalRbbn_grp')
        pm.parent(nurbs, grpFol, grpScale, arcLength, finalRbbnGrp)
Esempio n. 20
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)
Esempio n. 21
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
Esempio n. 22
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")
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)
    follicle.getParent().t.lock()
    follicle.getParent().r.lock()
Esempio n. 24
0
def rp_surface():
    """..............................................................................................//"""

    ncj = int(pm.intField('NCJ', q=1, v=1))
    # > control joints
    rn = float(pm.intField('NJ', q=1, v=1))
    bz = int(pm.checkBoxGrp('CTJP', q=1, v1=1))
    s = pm.ls(sl=1)
    rp_check(s)
    if pm.objExists(s[0] + "_surface"):
        rp_del()
        rp_cr()

    cj = pm.ls((s[0] + "_ctj_*"),
               typ="joint")
    x = 0.0
    if pm.optionMenuGrp('AXES', q=1, v=1) == "x":
        x = float(1)

    y = 0.0
    if pm.optionMenuGrp('AXES', q=1, v=1) == "y":
        y = float(1)

    z = 0.0
    if pm.optionMenuGrp('AXES', q=1, v=1) == "z":
        z = float(1)

    su = pm.extrude(s[0], upn=0, dl=3, ch=bz, d=(x, y, z), n=(s[0] + "_surface"), et=0, rn=0, po=0)
    pm.pm.cmds.move(((-1) * (x / 2)), ((-1) * (y / 2)), ((-1) * (z / 2)),
                    su[0])
    pm.makeIdentity(su[0], a=1, t=1)
    sj = pm.ls((s[0] + "_tw_*"),
               typ="joint")
    # pivot move
    t = (pm.xform(cj[0], q=1, ws=1, t=1))
    pm.setAttr((su[0] + ".rpx"), (t.x))
    pm.setAttr((su[0] + ".rpy"), (t.y))
    pm.setAttr((su[0] + ".rpz"), (t.z))
    pm.setAttr((su[0] + ".spx"), (t.x))
    pm.setAttr((su[0] + ".spy"), (t.y))
    pm.setAttr((su[0] + ".spz"), (t.z))
    # hairs
    hsys = str(pm.createNode("hairSystem", n=(s[0] + "_position")))
    hsysg = pm.listRelatives(hsys, p=1)
    pm.rename(hsysg[0],
              (s[0] + "_surface_grp_"))
    pm.select(su[0], hsys)
    pm.mel.createHair((len(sj)), 1, 2, 0, 0, 1, 1, 1, 0, 2, 2, 1)
    pm.delete((s[0] + "_surface_grp_"), (s[0] + "_surface_grp_OutputCurves"))
    # joints
    sg = pm.listRelatives((s[0] + "_surface_grp_Follicles"),
                          c=1)
    pm.delete(s[0] + "_tw_hl")
    for i in range(0, (len(sj))):
        pm.parent(sj[i], sg[i])
        pm.makeIdentity(sj[i], a=1, r=1)
        pm.connectAttr((s[0] + "_rig.s"), (sg[i] + ".s"),
                       f=1)

    pm.parent(su[0],
              (s[0] + "_sistem"))
    pm.parent((s[0] + "_surface_grp_Follicles"), (s[0] + "_sistem"))
    # conection scale joints
    if bz == 0:
        if pm.checkBoxGrp('CTJ', q=1, v1=1):
            for i in range(0, (len(cj))):
                pm.disconnectAttr((s[0] + "_" + str((i + 1)) + "_CT.change"), (cj[i] + ".sy"))
                pm.disconnectAttr((s[0] + "_" + str((i + 1)) + "_CT.change"), (cj[i] + ".sz"))

        pm.delete((s[0] + "_sx"), (s[0] + "_s"))

    sx = str(pm.createNode('multiplyDivide', n=(s[0] + "_pow")))
    # pow scale
    pm.setAttr((sx + ".op"),
               2)
    pm.connectAttr((s[0] + "_rig.s"), (sx + ".i2"),
                   f=1)
    pm.setAttr((sx + ".i1x"),
               1)
    pm.setAttr((sx + ".i1y"),
               1)
    pm.setAttr((sx + ".i1z"),
               1)
    pm.connectAttr((sx + ".o"), (s[0] + "_surface_grp_Follicles.s"),
                   f=1)
    # > skin
    fol = pm.ls((s[0] + "_surfaceFollicle*"),
                typ="transform")
    for i in range(0, (len(fol))):
        pm.setAttr((fol[i] + ".it"),
                   0)

    if bz == 0:
        pm.rebuildSurface(su[0], dv=1, du=3, sv=0, su=rn)
        pm.intField('NJ', e=1, v=rn)
        pm.skinCluster(cj, su[0], mi=2, rui=1, dr=2.0, n=(s[0] + "_skin_surface"))

    pm.setAttr((su[0] + ".it"),
               0)
    pm.setAttr((su[0] + ".tmp"),
               1)
    # > end
    pm.select(s[0])
Esempio n. 25
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
Esempio n. 26
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
Esempio n. 27
0
 def __createNurbs__(self):
     # check if plugin decompose matrix is present
     pmc.loadPlugin('decomposeMatrix', quiet=True)
     
     # create groups
     folGrp        = pmc.createNode('transform', name=self.name+'_fol_NXF',   parent=self.grp, skipSelect=True)
     self.strucGrp = pmc.createNode('transform', name=self.name+'_struc_NXF', parent=self.grp, skipSelect=True)
     folGrp.inheritsTransform.set(0)
     self.strucGrp.inheritsTransform.set(0)
     
     # create plane
     plan = pmc.nurbsPlane(name=self.name+'_plane', axis=[0,1,0], width=self.length, lengthRatio=(1.0/self.length)/2.0, degree=3, patchesU=4, patchesV=1, constructionHistory=0, pivot=[self.length/2.0,0,0])[0]
     plan.inheritsTransform.set(0)
     plan.setParent(folGrp)
     pmc.rebuildSurface( plan, constructionHistory=False, replaceOriginal=True, rebuildType=0, endKnots=1, keepRange=0, keepControlPoints=0, keepCorners=0, spansV=1, degreeV=1, fitRebuild=0,  direction=1 )
     
     # create follicle + control + bones
     self.subCtrlGrp = []
     self.subCtrl    = []
     self.bones2SK   = []
     
     for i in range(self.nbItem):
         fol      = pmc.createNode('transform', name=self.name+'_fol'+str(i+1),         parent=folGrp, skipSelect=True)
         folShape = pmc.createNode('follicle',  name=self.name+'_fol'+str(i+1)+'Shape', parent=fol,    skipSelect=True)
         # connections
         plan.worldMatrix[0] >> folShape.inputWorldMatrix
         plan.local >> folShape.inputSurface
         folShape.outRotate >> fol.rotate
         folShape.outTranslate >> fol.translate
         # u and v setting
         folShape.parameterV.set(0.5)
         folShape.parameterU.set((1.0/(self.nbItem-1.0))*i)
         folShape.visibility.set(False)
         clean.__lockHideTransform__(fol, channel=['t', 'r', 's', 'v'])
         
         # sub control
         self.subCtrlGrp.append( pmc.createNode('transform', name=self.name+'_sub'+str(i+1)+'_grp') )
         self.subCtrl.append( shapesBiblio.rhombusX(name=self.name+'_sub'+str(i+1), color=self.colorTwo) )
         # add attributs
         pmc.addAttr(self.subCtrl[i], longName='posU', attributeType='float', defaultValue=((1.0/(self.nbItem-1.0))*i) )
         pmc.addAttr(self.subCtrl[i], longName='negU', attributeType='float', defaultValue=1-((1.0/(self.nbItem-1.0))*i) )
         
         self.subCtrl[-1].setParent(self.subCtrlGrp[-1])
         self.subCtrlGrp[-1].setParent(fol)
         self.subCtrlGrp[-1].setTranslation([0,0,0], space='object')
         xfm.__xfm__(self.subCtrlGrp[-1])
         
         # bones
         self.bones2SK.append( bn.create2SK(self.name+'_sub'+str(i+1), self.subCtrl[-1]) )
     
     
     # pickwalk
     arPickwalk.setPickWalk(self.subCtrl, type='UD')
     
     # create structure
     strucJnt       = []
     self.strucCtrl = {}
     for i in range(len(self.ctrlName)):
         strucTmp = []
         if i == 1:
             # ctrl
             strucTmp.append( shapesBiblio.circleX(name=self.name+'_'+self.ctrlName[i], parent=self.strucGrp, color=self.colorOne) )
             clean.__lockHideTransform__(strucTmp[-1], channel=['s'])
             strucJnt.append( pmc.createNode('joint', name=self.name+'_'+self.ctrlName[i]+'_RIGjnt', parent=strucTmp[-1], skipSelect=True) )
             
             # aim
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_pos', parent=self.strucGrp, skipSelect=True) )
             
             # rot 
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_aim', parent=strucTmp[-1], skipSelect=True) )
             strucTmp[0].setParent(strucTmp[-1])
             
             # up
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_up',  parent=strucTmp[-2], skipSelect=True) )
             strucTmp[-1].setTranslation([0,self.length/2.0,0], space='world')
             
         else:
             # ctrl
             strucTmp.append( shapesBiblio.circleX(name=self.name+'_'+self.ctrlName[i], parent=self.strucGrp, color=self.colorOne) )
             clean.lockHideTransform(strucTmp[-1], channel=['rotateOrder'])
             
             # aim
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_aim', parent=strucTmp[-1], skipSelect=True) )
             strucJnt.append( pmc.createNode('joint', name=self.name+'_'+self.ctrlName[i]+'_RIGjnt', parent=strucTmp[-1], skipSelect=True) )
             
             # scale
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_scl',    parent=strucTmp[-1],  skipSelect=True) )
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_locScl', parent=strucTmp[-1], skipSelect=True) )
             
             # local scale connection
             strucTmp[0].scale >> strucTmp[-1].scale
             
             # up
             strucTmp.append( pmc.createNode('transform', name=self.name+'_'+self.ctrlName[i]+'_up',  parent=strucTmp[-4], skipSelect=True) )
             strucTmp[-1].setTranslation([0,self.length/2.0,0], space='world')
         
         # put info into dico
         self.strucCtrl[self.ctrlName[i]] = strucTmp
     
     # place structure end
     self.strucCtrl[self.ctrlName[2]][0].setTranslation([self.length,0,0], space='world')
     
     # pickwalk
     arPickwalk.setPickWalk([self.strucCtrl[self.ctrlName[0]][0], self.strucCtrl[self.ctrlName[1]][0], self.strucCtrl[self.ctrlName[2]][0]], type='UD')
     arPickwalk.setPickWalk([self.strucCtrl[self.ctrlName[0]][0], self.subCtrl[0]], type='LR')
     arPickwalk.setPickWalk([self.strucCtrl[self.ctrlName[2]][0], self.subCtrl[-1]], type='LR')
     
     # create constrain group
     self.strucCtrlGrp = []
     self.strucCtrlGrp.append( xfm.__xfm__(self.strucCtrl[self.ctrlName[0]][0], suffix='_cst_grp', lock=False) )
     self.strucCtrlGrp.append( xfm.__xfm__(self.strucCtrl[self.ctrlName[1]][0], suffix='_cst_grp', lock=False) )
     self.strucCtrlGrp.append( xfm.__xfm__(self.strucCtrl[self.ctrlName[2]][0], suffix='_cst_grp', lock=False) )
     
     
     # constrain between structure
     tmp = []
     tmp.append( pmc.pointConstraint(self.strucCtrl[self.ctrlName[0]][0], self.strucCtrl[self.ctrlName[2]][0], self.strucCtrl[self.ctrlName[1]][1], name=self.strucCtrl[self.ctrlName[1]][1]+'_ptCst', maintainOffset=False ) )
     tmp.append( pmc.pointConstraint(self.strucCtrl[self.ctrlName[0]][4], self.strucCtrl[self.ctrlName[2]][4], self.strucCtrl[self.ctrlName[1]][3], name=self.strucCtrl[self.ctrlName[1]][3]+'_ptCst', maintainOffset=False ) )
     tmp.append( pmc.aimConstraint(self.strucCtrl[self.ctrlName[2]][0], self.strucCtrl[self.ctrlName[0]][1], name=self.strucCtrl[self.ctrlName[0]][1]+'_aimCst', maintainOffset=False, worldUpType='object', worldUpObject=self.strucCtrl[self.ctrlName[0]][4], aimVector=[1,0,0],  upVector=[0,1,0]) )
     tmp.append( pmc.aimConstraint(self.strucCtrl[self.ctrlName[0]][0], self.strucCtrl[self.ctrlName[2]][1], name=self.strucCtrl[self.ctrlName[2]][1]+'_aimCst', maintainOffset=False, worldUpType='object', worldUpObject=self.strucCtrl[self.ctrlName[2]][4], aimVector=[-1,0,0], upVector=[0,1,0]) )
     tmp.append( pmc.aimConstraint(self.strucCtrl[self.ctrlName[2]][0], self.strucCtrl[self.ctrlName[1]][2], name=self.strucCtrl[self.ctrlName[1]][2]+'_aimCst', maintainOffset=False, worldUpType='object', worldUpObject=self.strucCtrl[self.ctrlName[1]][3], aimVector=[1,0,0],  upVector=[0,1,0]) )
     
     clean.lockHideTransform(tmp, channelBox=True)
     
     
     
     # skinning nurbs plane
     skinNode = pmc.skinCluster( strucJnt[0], strucJnt[1], strucJnt[2], plan, name=plan.name()+'_skn', ignoreSelected=0, maximumInfluences=3, dropoffRate=12.0, normalizeWeights=1)
     weights = []
     weights.extend([1, 0, 0])
     weights.extend([1, 0, 0])
     weights.extend([0.8, 0.2, 0])
     weights.extend([0.8, 0.2, 0])
     weights.extend([0.4, 0.6, 0])
     weights.extend([0.4, 0.6, 0])
     weights.extend([0, 1, 0])
     weights.extend([0, 1, 0])
     weights.extend([0, 0.6, 0.4])
     weights.extend([0, 0.6, 0.4])
     weights.extend([0, 0.2, 0.8])
     weights.extend([0, 0.2, 0.8])
     weights.extend([0, 0, 1])
     weights.extend([0, 0, 1])
     
     # set weights
     skinNode[0].setWeights(plan, [0,1,2], weights, normalize=True)
     
     # delete useless bindpose
     bindPose = strucJnt[0].bindPose.outputs()[0]
     pmc.delete(bindPose)
     
     
     # inverse scale for bones
     for i in range(len(self.ctrlName)):
         multMat = pmc.createNode('multMatrix',      name=self.strucCtrl[self.ctrlName[i]][0]+'_invScl_multMat', skipSelect=True)
         decoMat = pmc.createNode('decomposeMatrix', name=self.strucCtrl[self.ctrlName[i]][0]+'_invScl_decoMat', skipSelect=True)
         self.strucGrp.inverseMatrix >> multMat.matrixIn[0]
         self.strucCtrl[self.ctrlName[i]][0].worldMatrix[0] >> multMat.matrixIn[1]
         
         multMat.matrixSum >> decoMat.inputMatrix
         decoMat.outputScale >> strucJnt[i].inverseScale
     
     
     
     # connect scale from controlors to sub
     decoMatS = pmc.createNode('decomposeMatrix', name=self.strucCtrl[self.ctrlName[0]][0]+'_decoMat', skipSelect=True)
     decoMatE = pmc.createNode('decomposeMatrix', name=self.strucCtrl[self.ctrlName[2]][0]+'_decoMat', skipSelect=True)
     
     self.strucCtrl[self.ctrlName[0]][3].worldMatrix[0] >> decoMatS.inputMatrix
     self.strucCtrl[self.ctrlName[2]][3].worldMatrix[0] >> decoMatE.inputMatrix
      
     
     # connect scale to sub control
     for i in range(1, self.nbItem-1):
         # create blend to progressively pass from the start to the end scale
         bld = pmc.createNode('blendColors', name=self.subCtrl[i].name()+str(i)+'_bld')
         decoMatS.outputScale >> bld.color1
         decoMatE.outputScale >> bld.color2
         # connect the sub control attribut neg U
         self.subCtrl[i].negU >> bld.blender
         # connect into the scale
         bld.output >> self.subCtrlGrp[i].scale
     # no point to create a blend node for the first and the last sub control
     decoMatS.outputScale >> self.subCtrlGrp[0].scale
     decoMatE.outputScale >> self.subCtrlGrp[-1].scale
     
     
     
     # hide and lock channels
     plan.visibility.set(False)
     clean.__lockHideTransform__(plan,   channel=['t', 'r', 's', 'v'])
     clean.__lockHideTransform__(folGrp, channel=['t', 'r', 's', 'v'])
     
     for jnt in strucJnt:
         jnt.overrideEnabled.set(1)
         jnt.overrideColor.set(3)
         jnt.radius.set(0.5)
         jnt.visibility.set(False)
         clean.__lockHideTransform__(jnt, channel=['t', 'r', 's', 'v', 'radius'])
     
     
     
     # unselect
     pmc.select(clear=True)
     
     
     # return, in order
     #   0 the main group PyNode
     #   1 the main structure group this last can receive constrain to place the ribbon PyNode
     #   2 groups of each structure controls in order (start offset end) PyNode List
     #   3 structure controls in order (start offset end) PyNode List)
     #   4 groups wich can receive a scale information in order (start end) PyNode List
     #   5 position groups which give the default position in order (offset) PyNode
     #   6 groups of sub controls PyNode List
     #   7 sub controls PyNode List
     #   8 2SKjnt PyNode List
     return [self.grp, self.strucGrp, self.strucCtrlGrp, [self.strucCtrl[self.ctrlName[0]][0], self.strucCtrl[self.ctrlName[1]][0], self.strucCtrl[self.ctrlName[2]][0]], [self.strucCtrl[self.ctrlName[0]][2], self.strucCtrl[self.ctrlName[2]][2]], self.strucCtrl[self.ctrlName[1]][1], self.subCtrlGrp, self.subCtrl, self.bones2SK]
Esempio n. 28
0
 def uniform_rebuild(self, number_of_points):
     rebuild_surf = pm.rebuildSurface(self.skin_surface, rebuildType=0,
                                      spansV=number_of_points,
                                      keepRange=True)
     self.skin_surface = rebuild_surf[0]