Exemple #1
0
def build():

    ctrl = nurbsPlane(ax=[0, 1, 0], w=1, d=1, lr=1)[0]
    move(ctrl.cv, [0, 0.5, 0], r=1, os=1, wd=True)
    other = nurbsPlane(ax=[0, 1, 0], w=1, d=1, lr=1)[0]
    move(other.cv, [0, -0.5, 0], r=1, os=1, wd=True)

    points = [
        (-0.5, 0, 0.5),
        (0.5, 0, 0.5),
        (0.5, 0, -0.5),
        (-0.5, 0, -0.5),
        (-0.5, 0, 0.5),
    ]

    line = curve(p=[(p[0], p[1] + .5, p[2])
                    for p in points] + [(p[0], p[1] - .5, p[2])
                                        for p in points],
                 d=1)
    line.rename('outline')

    other.getShape().setParent(ctrl, add=True, shape=True)
    line.getShape().setParent(ctrl, add=True, shape=True)

    delete(line, other)

    return ctrl
    def test_clusterPlane(self):
        fr = FollowRibbon.FollowRibbon(name="blah")
        plane = pm.nurbsPlane(axis=[0, 1, 0], patchesU=8, patchesV=1, lengthRatio=0.1, ch=0)[0]
        ctrls = []
        ctrls.append(pm.circle(n="blah_ctrl_01")[0].name())
        ctrls.append(pm.circle(n="blah_ctrl_02")[0].name())
        mainGrp = pm.group(em=1, name="main")

        result = fr._clusterPlane(plane=plane, controls=ctrls, mainGrp="main")

        self.testLib.assertListEqual(result, ["blah_cluster_01Handle", "blah_cluster_02Handle"])
        self.assertTrue(pm.objExists("blah_cluster_01"))
        self.assertTrue(pm.objExists("blah_cluster_02"))

        self.assertTrue(pm.listRelatives(result[0], parent=True), "main")
        self.assertTrue(pm.listRelatives(result[1], parent=True), "main")

        self.assertTrue(pm.listRelatives(result[0], parent=1)[0], "blah_ctrlsGrp")
        self.assertTrue(pm.listRelatives(result[1], parent=1)[0], "blah_ctrlsGrp")

        hist = pm.listHistory(plane)
        hitA = 0
        hitB = 0
        for each in hist:
            if each.name() == "blah_cluster_01":
                hitA = 1
            if each.name() == "blah_cluster_02":
                hitB = 1
        self.assertTrue(hitA)
        self.assertTrue(hitB)

        self.assertTrue(pm.isConnected("blah_ctrl_01.translate", "blah_cluster_01Handle.translate"))
        self.assertTrue(pm.isConnected("blah_ctrl_02.translate", "blah_cluster_02Handle.translate"))
Exemple #3
0
def camera_focus_plane_tool():
    """sets up a focus plane for the selected camera
    """
    camera = pm.ls(sl=1)[0]
    camera_shape = camera.getShape()

    frame = pm.nurbsPlane(
        n='focusPlane#',
        p=(0, 0, 0), ax=(0, 0, 1), w=1, lr=1, d=1, u=1, v=1, ch=0
    )[0]
    frame_shape = frame.getShape()
    pm.parent(frame, camera, r=True)

    #transform the frame surface
    frame.tz.set(-10.0)

    exp = """float $flen = %(camera)s.focalLength;
    float $hfa = %(camera)s.horizontalFilmAperture * 25.4;
    %(frame)s.sx = -%(frame)s.translateZ * $hfa/ $flen;
    %(frame)s.sy = %(frame)s.sx / defaultResolution.deviceAspectRatio;
    %(camera)s.focusDistance = -%(frame)s.tz;
    %(camera)s.aiFocusDistance = %(camera)s.focusDistance;
    %(camera)s.aiApertureSize = %(camera)s.focalLength / %(camera)s.fStop * 0.1;
    """ % {
        'camera': camera_shape.name(),
        'frame': frame.name()
    }
    pm.expression(s=exp, ae=1, uc="all")

    # set material
    surface_shader = pm.shadingNode('surfaceShader', asShader=1)
    pm.select(frame)
    pm.hyperShade(a=surface_shader.name())

    surface_shader.setAttr('outColor', (0.4, 0, 0))
    surface_shader.setAttr('outTransparency', (0.5, 0.5, 0.5))

    # prevent it from being rendered
    frame_shape.setAttr('castsShadows', 0)
    frame_shape.setAttr('receiveShadows', 0)
    frame_shape.setAttr('motionBlur', 0)
    frame_shape.setAttr('primaryVisibility', 0)
    frame_shape.setAttr('smoothShading', 0)
    frame_shape.setAttr('visibleInReflections', 0)
    frame_shape.setAttr('visibleInRefractions', 0)

    # Arnold attributes
    frame_shape.setAttr('aiSelfShadows', 0)
    frame_shape.setAttr('aiVisibleInDiffuse', 0)
    frame_shape.setAttr('aiVisibleInGlossy', 0)

    # hide unnecessary attributes
    frame.setAttr('tx', lock=True, keyable=False)
    frame.setAttr('ty', lock=True, keyable=False)
    frame.setAttr('rx', lock=True, keyable=False)
    frame.setAttr('ry', lock=True, keyable=False)
    frame.setAttr('rz', lock=True, keyable=False)
    frame.setAttr('sx', lock=True, keyable=False)
    frame.setAttr('sy', lock=True, keyable=False)
    frame.setAttr('sz', lock=True, keyable=False)
Exemple #4
0
def camera_focus_plane_tool():
    """sets up a focus plane for the selected camera
    """
    camera = pm.ls(sl=1)[0]
    camera_shape = camera.getShape()

    frame = pm.nurbsPlane(
        n='focusPlane#',
        p=(0, 0, 0), ax=(0, 0, 1), w=1, lr=1, d=1, u=1, v=1, ch=0
    )[0]
    frame_shape = frame.getShape()
    pm.parent(frame, camera, r=True)

    #transform the frame surface
    frame.tz.set(-10.0)

    exp = """float $flen = %(camera)s.focalLength;
    float $hfa = %(camera)s.horizontalFilmAperture * 25.4;
    %(frame)s.sx = -%(frame)s.translateZ * $hfa/ $flen;
    %(frame)s.sy = %(frame)s.sx / defaultResolution.deviceAspectRatio;
    %(camera)s.focusDistance = -%(frame)s.tz;
    %(camera)s.aiFocusDistance = %(camera)s.focusDistance;
    %(camera)s.aiApertureSize = %(camera)s.focalLength / %(camera)s.fStop * 0.1;
    """ % {
        'camera': camera_shape.name(),
        'frame': frame.name()
    }
    pm.expression(s=exp, ae=1, uc="all")

    # set material
    surface_shader = pm.shadingNode('surfaceShader', asShader=1)
    pm.select(frame)
    pm.hyperShade(a=surface_shader.name())

    surface_shader.setAttr('outColor', (0.4, 0, 0))
    surface_shader.setAttr('outTransparency', (0.5, 0.5, 0.5))

    # prevent it from being rendered
    frame_shape.setAttr('castsShadows', 0)
    frame_shape.setAttr('receiveShadows', 0)
    frame_shape.setAttr('motionBlur', 0)
    frame_shape.setAttr('primaryVisibility', 0)
    frame_shape.setAttr('smoothShading', 0)
    frame_shape.setAttr('visibleInReflections', 0)
    frame_shape.setAttr('visibleInRefractions', 0)

    # Arnold attributes
    frame_shape.setAttr('aiSelfShadows', 0)
    frame_shape.setAttr('aiVisibleInDiffuse', 0)
    frame_shape.setAttr('aiVisibleInGlossy', 0)

    # hide unnecessary attributes
    frame.setAttr('tx', lock=True, keyable=False)
    frame.setAttr('ty', lock=True, keyable=False)
    frame.setAttr('rx', lock=True, keyable=False)
    frame.setAttr('ry', lock=True, keyable=False)
    frame.setAttr('rz', lock=True, keyable=False)
    frame.setAttr('sx', lock=True, keyable=False)
    frame.setAttr('sy', lock=True, keyable=False)
    frame.setAttr('sz', lock=True, keyable=False)
Exemple #5
0
def control_grp_have_joint(name,
                           object_type="plane",
                           parent_node=None,
                           jnt_vis=False):
    u"""包含子骨骼的控制器组

    :param name: 控制器名
    :param object_type: 控制器的样式
    :param parent_node: 父节点
    :return: 控制器组
    """
    grp = pm.createNode("transform", name="{}_Grp".format(name))
    if object_type == "plane":
        pm.parent(
            pm.nurbsPlane(name=name,
                          p=[0, 0, 0],
                          ax=[0, 0, 1],
                          w=1,
                          lr=1,
                          d=1,
                          u=1,
                          v=1,
                          ch=0), grp)
    pm.select(cl=True)
    jnt = pm.joint(name="{}_Jnt".format(name))
    jnt.visibility.set(jnt_vis)
    pm.parent(jnt, name)
    if parent_node is not None:
        pm.parent(grp, parent_node)
        grp.translate.set([0, 0, 0])
        grp.rotate.set([0, 0, 0])
        grp.scale.set([1, 1, 1])
    return grp
Exemple #6
0
def createNurbSurf(numJoints, name):
	""" From two selected objects will create a nurbs curve with follicle """
	
	front, end = pm.selected()
	distance = getDistance(front, end)
	nurbsSurf = pm.nurbsPlane(p = [0,0,0], ax =[0,1,0], w=1, lr=distance, d=3,u=1, v=numJoints, ch=1, n = name + '_Sur')
	
	vCoord = 1.0/numJoints
	follicleList = []
	
	# this section can also use CMuscleSurfAttach, 
	# found that muscle surface attach is less efficient
	for i in range(numJoints):
		fol = pm.createNode('transform', n= name + '_fol#', ss=True)
		folShape = pm.createNode('follicle', n=fol.name() + 'Shape', p=fol, ss=True)
		nurbsSurf[0].local >> folShape.inputSurface
		nurbsSurf[0].worldMatrix[0] >> folShape.inputWorldMatrix
		folShape.outRotate >> fol.rotate
		folShape.outTranslate >> fol.translate
		fol.inheritsTransform.set(False)
		folShape.parameterU.set(0.5)
		folShape.simulationMethod.set(0)
		
		curV = vCoord * (i + 1)
		nextV = vCoord * (i)
		midV = (curV + nextV) * 0.5
		logger.debug('The average of ' + str(curV) + ' and ' + str(nextV) + ' is ' + str(midV) + '. Setting follicle position to sum.')
		folShape.parameterV.set(midV)
		follicleList.append(fol)
	pm.group(follicleList, n = name + '_fol_GRP')
	return follicleList, nurbsSurf, front, end
    def create_ribbon(self, ribbon_length, number_of_follicles):
        ribbon, ribbon_make_nurb = pm.nurbsPlane(p=[0, 0, 0],
                                                 ax=[0, 0, 1],
                                                 w=ribbon_length,
                                                 lr=0.2,
                                                 d=3,
                                                 u=8,
                                                 v=1,
                                                 ch=1)
        ribbon_shape = ribbon.getShape()
        ribbon.rename(self.namespace + "ribbon_nurbs")

        follicle_percentage = 1.0 / (number_of_follicles - 1)
        follicle_list = []
        for i in range(number_of_follicles):
            follicle = pm.createNode("follicle",
                                     n="{0}follicle_{1}".format(
                                         self.namespace, i),
                                     ss=True)
            follicle_list.append(follicle)
            follicle.parameterU.set(i * follicle_percentage)
            follicle.parameterV.set(0.5)
            follicle_transform = follicle.getParent()

            follicle.outRotate >> follicle_transform.rotate
            follicle.outTranslate >> follicle_transform.translate

            ribbon_shape.local >> follicle.inputSurface
            ribbon_shape.worldMatrix >> follicle.inputWorldMatrix

        return ribbon, follicle_list
    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)
Exemple #9
0
def polyQuadToNurbs(f):
    pts = f.getPoints()
    # must rearrange pts - they come in in clockwise fashion,
    # indeces 2 and 3 must be swapped
    pts[2], pts[3] = pts[3], pts[2]
    pl = pmc.nurbsPlane(d=1, ch=0)[0]
    pl.setCVs(pts)
    pl.updateSurface()
    return pl
Exemple #10
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]
Exemple #11
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)
def createPlane():
    sel = pm.ls(sl = True)[0]
    
    selChild = sel.listRelatives(c = True, typ = 'joint')[0]
    planSize = selChild.translateX.get()
    
    onePlan = pm.nurbsPlane(ch = True, o = True, po = False, ax = [0,1,0], w = planSize, lr = 0.25, u = 3)
    onePlan[0].setParent(sel)
    onePlan[0].translate.set([planSize/2,0,0])
    onePlan[0].rotate.set([0,0,0])
    pm.parent(onePlan, w = True)
    def test_createDriveControls(self):
        fr = FollowRibbon.FollowRibbon(name="blah")
        plane = pm.nurbsPlane(axis=[0, 1, 0], patchesU=8, patchesV=1, lengthRatio=0.1, ch=0)[0]
        grps, jnts, cposNodes = fr._createPlaneControls(plane=plane, direction="u", number=4)

        mainGrp, ctrls = fr._createDriveControls(grps=grps, cposNodes=cposNodes)

        self.assertEqual(mainGrp, "blah_ctrlsGrp")
        self.testLib.assertListEqual(ctrls, ["blah_ctrl_01", "blah_ctrl_02", "blah_ctrl_03", "blah_ctrl_04"])

        for index in range(4):
            self.assertTrue(pm.objExists("blah_ctrlTopGrp_%s" % str(index + 1).zfill(2)))
            self.assertTrue(pm.objExists("blah_ctrlMidGrp_%s" % str(index + 1).zfill(2)))
            self.assertTrue(pm.objExists("blah_ctrlBtmGrp_%s" % str(index + 1).zfill(2)))
            self.assertTrue(pm.objExists("blah_InvertMdNode_%s" % str(index + 1).zfill(2)))
            self.assertTrue(pm.objExists("blah_ctrl_%s" % str(index + 1).zfill(2)))

            self.assertEqual(
                pm.listRelatives("blah_ctrlTopGrp_%s" % str(index + 1).zfill(2), parent=1)[0].name(), "blah_ctrlsGrp"
            )

            self.testLib.assertConstrained(
                grps[index].name(), "blah_ctrlTopGrp_%s" % str(index + 1).zfill(2), type="parent"
            )

            self.assertTrue(
                pm.isConnected(
                    "blah_ctrl_%s.translate" % str(index + 1).zfill(2),
                    "blah_InvertMdNode_%s.input1" % str(index + 1).zfill(2),
                )
            )
            self.assertTrue(
                pm.isConnected(
                    "blah_InvertMdNode_%s.output" % str(index + 1).zfill(2),
                    "blah_ctrlBtmGrp_%s.translate" % str(index + 1).zfill(2),
                )
            )

            self.assertTrue(pm.objExists("blah_ctrl_%s.uParam" % str(index + 1).zfill(2)))
            self.assertTrue(pm.objExists("blah_ctrl_%s.vParam" % str(index + 1).zfill(2)))

            self.assertTrue(
                pm.isConnected(
                    "blah_ctrl_%s.uParam" % str(index + 1).zfill(2),
                    "blah_drvCPOS_%s.parameterU" % str(index + 1).zfill(2),
                )
            )
            self.assertTrue(
                pm.isConnected(
                    "blah_ctrl_%s.vParam" % str(index + 1).zfill(2),
                    "blah_drvCPOS_%s.parameterV" % str(index + 1).zfill(2),
                )
            )
Exemple #14
0
    def create_guide(self, parent):

        if self.options.use_nurbs:
            xform, _ = pm.nurbsPlane(p=[0, 0, 0],
                                     ax=[0, 0, 1],
                                     w=1,
                                     lr=1,
                                     d=3,
                                     u=1,
                                     v=1,
                                     ch=1)

        else:
            # -- Create the mesh
            xform, _ = pm.polyPlane(
                w=1,
                h=1,
                sx=1,
                sy=1,
                ax=[0, 1, 0],
                cuv=2,
                ch=1,
            )

        # -- Clear all history
        pm.delete(xform, constructionHistory=True)

        # -- Re-get the surface, as we're not working with a polyPlane any longer
        # -- but instead a mesh shape
        surface = xform.getShape()

        # -- Parent the surface under guide root
        xform.setParent(parent)

        # -- Tag the surface so we can retrieve it later
        self.tag(xform, 'GuideSurface')

        # -- Now create the follicle
        follicle = self.create_follicle(
            description='Guide{}'.format(self.options.description),
            side=self.options.side,
            parent=parent,
            surface=surface,
            u=0.5,
            v=0.5,
        )
        follicle.visibility.set(False)

        # -- Tag the surface so we can retrieve it later
        self.tag(follicle, 'GuideFollicle')

        return True
Exemple #15
0
def build():
    ctrl = nurbsPlane(axis=[0, 1, 0], u=2, d=1)[0]
    xform(ctrl.cv[2][0], ws=True, t=[0.5, 0, 0.2])
    xform(ctrl.cv[0][0], ws=True, t=[-0.5, 0, 0.2])

    line = curve(d=True,
                 p=[(-0.5, 0, -0.5), (-0.5, 0, 0.2), (0, 0, 0.5),
                    (0.5, 0, 0.2), (0.5, 0, -0.5), (-0.5, 0, -0.5)])
    line.rename('outline')
    line.getShape().setParent(ctrl, add=True, shape=True)
    delete(line)

    return ctrl
Exemple #16
0
def makeSimpleSurf(name="UNTITLED_SURF_RIG"):
    """Create a 2x3 span nurbs plane at the average position of selection
    with the average normal."""
    sel = getSymSelection()
    if sel:
        vts = getConnectedCmpnts(sel, "Vertices")
        normal = getPolyAvgNormal(vts)
        pos = sum(v.getPosition("world") for v in vts) / len(vts)
    else:
        pmc.warning("No guide edges selected, surface created at origin.")
        normal = (1, 0, 0)
        pos = (0, 0, 0)

    return pmc.nurbsPlane(u=3, v=2, ch=0, axis=normal, p=pos, n=name)[0]
Exemple #17
0
 def create_plane(self, name, width=10, lengthratio=0.2):
     """
     Create NURBS plane
     :param name: string
     :param width:
     :param lengthratio:
     :return:
     """
     nurbs_plane = pm.nurbsPlane(name=name,
                                 width=width,
                                 lengthRatio=lengthratio,
                                 patchesU=width / 2,
                                 degree=3,
                                 axis=[0, 1, 0],
                                 constructionHistory=False)
     return nurbs_plane
Exemple #18
0
def createPlane():
    sel = pm.ls(sl=True)[0]

    selChild = sel.listRelatives(c=True, typ='joint')[0]
    planSize = selChild.translateX.get()

    onePlan = pm.nurbsPlane(ch=True,
                            o=True,
                            po=False,
                            ax=[0, 1, 0],
                            w=planSize,
                            lr=0.25,
                            u=3)
    onePlan[0].setParent(sel)
    onePlan[0].translate.set([planSize / 2, 0, 0])
    onePlan[0].rotate.set([0, 0, 0])
    pm.parent(onePlan, w=True)
Exemple #19
0
 def build_plane(self, *args):
     """ builds Nurb plane based on joint slider
     Args:
         None
     Returns (None)
     """
     surface_name = self.flexiPlaneNameField.getText() + '_flexiPlane_SURF'
     num_nurb_patches = self.flexiPlaneNumSlider.getValue()
     nurb_plane_width = self.flexiPlaneNumSlider.getValue() * 2
     nurb_plane_length_ratio = float(2) / nurb_plane_width
     
     surface = pm.nurbsPlane(p= (0, 0, 0), ax= (0, 1, 0), w= nurb_plane_width, lr= nurb_plane_length_ratio, d= 3, u= num_nurb_patches, v= 1, n= surface_name, ch= 0)[0]
     surface_shape = surface.getShape()
     attrs = ['castsShadows', 'receiveShadows', 'motionBlur', 'primaryVisibility', 'smoothShading', 'visibleInReflections', 'visibleInRefractions']
     for attr in attrs:
         surface_shape.attr(attr).set(0)
     surface.setAttr('inheritsTransform', 0)
     return surface
Exemple #20
0
    def test_clusterPlane(self):
        fr = FollowRibbon.FollowRibbon(name='blah')
        plane = pm.nurbsPlane(axis=[0, 1, 0],
                              patchesU=8,
                              patchesV=1,
                              lengthRatio=.1,
                              ch=0)[0]
        ctrls = []
        ctrls.append(pm.circle(n='blah_ctrl_01')[0].name())
        ctrls.append(pm.circle(n='blah_ctrl_02')[0].name())
        mainGrp = pm.group(em=1, name='main')

        result = fr._clusterPlane(plane=plane, controls=ctrls, mainGrp='main')

        self.testLib.assertListEqual(
            result, ['blah_cluster_01Handle', 'blah_cluster_02Handle'])
        self.assertTrue(pm.objExists('blah_cluster_01'))
        self.assertTrue(pm.objExists('blah_cluster_02'))

        self.assertTrue(pm.listRelatives(result[0], parent=True), 'main')
        self.assertTrue(pm.listRelatives(result[1], parent=True), 'main')

        self.assertTrue(
            pm.listRelatives(result[0], parent=1)[0], 'blah_ctrlsGrp')
        self.assertTrue(
            pm.listRelatives(result[1], parent=1)[0], 'blah_ctrlsGrp')

        hist = pm.listHistory(plane)
        hitA = 0
        hitB = 0
        for each in hist:
            if each.name() == 'blah_cluster_01':
                hitA = 1
            if each.name() == 'blah_cluster_02':
                hitB = 1
        self.assertTrue(hitA)
        self.assertTrue(hitB)

        self.assertTrue(
            pm.isConnected('blah_ctrl_01.translate',
                           'blah_cluster_01Handle.translate'))
        self.assertTrue(
            pm.isConnected('blah_ctrl_02.translate',
                           'blah_cluster_02Handle.translate'))
Exemple #21
0
    def nurbPlaneBetweenObjects(self, Object01, Object02):
        VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True))
        VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True))
        longitud = VP1 - VP2
        plano = pm.nurbsPlane(ax=[0, 1, 0],
                              p=[(longitud.length()) / 2, 0, 0],
                              w=longitud.length(),
                              lr=.05,
                              d=3,
                              u=8,
                              v=1,
                              ch=0,
                              name="%sTo%sPlane" %
                              (self.name_conv.get_a_short_name(Object01),
                               self.name_conv.get_a_short_name(Object02)))
        self.name_conv.set_name_in_format(plano, useName=True)

        RMRigTools.RMAlign(Object01, plano[0], 3)
        return plano[0]
Exemple #22
0
    def nurbPlaneBetweenObjects(self, Object01, Object02):
        VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True))
        print VP1
        VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True))
        print VP2
        longitud = VP1 - VP2
        plano = pm.nurbsPlane(ax=[0, 1, 0],
                              p=[(longitud.length()) / 2, 0, 0],
                              w=longitud.length(),
                              lr=.05,
                              d=3,
                              u=8,
                              v=1,
                              ch=0,
                              name="bendyPlane")
        self.name_conv.rename_name_in_format(plano, useName=True)

        pm.matchTransform(plano[0], Object01)
        return plano[0]
Exemple #23
0
    def nurb_plane_between_objects(self, object_a, object_b):
        vector_a = om.MVector(
            pm.xform(object_a, a=True, ws=True, q=True, rp=True))
        vector_b = om.MVector(
            pm.xform(object_b, a=True, ws=True, q=True, rp=True))
        length = vector_a - vector_b
        plano = pm.nurbsPlane(ax=[0, 1, 0],
                              p=[(length.length()) / 2, 0, 0],
                              w=length.length(),
                              lr=.05,
                              d=3,
                              u=8,
                              v=1,
                              ch=0,
                              name="bendyPlane")
        self.name_convention.rename_name_in_format(plano[0], useName=True)

        pm.matchTransform(plano[0], object_a)
        return plano[0]
Exemple #24
0
def build():
    #crv = curve( d=1, p=((0, 0, 0), (0, 0, .5)))
    #ctrl = revolve( crv, ch=False, ssw=0, esw=360, degree=3, ax=[0, 1, 0] )[0]
    
    line = curve(d=1, p=[
        (-0.5, 0, 0.5),
        (0.5, 0, 0.5),
        (0.5, 0, -0.5),
        (-0.5, 0, -0.5),
        (-0.5, 0, 0.5),
        ]  # noqa
    )

    line.rename('outline')

    ctrl = nurbsPlane( ax=[0, 1, 0], w=1, d=1, lr=1 )[0]

    line.getShape().setParent( ctrl, add=True, shape=True )
    delete(line)

    return ctrl
Exemple #25
0
    def make_chain_surface(cls, spans=10):
        count = 1
        nurbs = pm.nurbsPlane(u=1, v=spans, lr=5, n="surface")
        geo = pm.PyNode(nurbs[0])
        fols = []
        fol_shapes = []
        while count < spans:
            fol = pm.createNode('transform', n='follicle1', ss=True)
            fol_shape = pm.createNode('follicle',
                                      name="folicle_shape",
                                      p=fol,
                                      ss=True)
            pm.connectAttr(geo.local, fol_shape.inputSurface)
            pm.connectAttr(geo.worldMatrix[0], fol_shape.inputWorldMatrix)
            pm.connectAttr(fol_shape.outRotate, fol.rotate)
            pm.connectAttr(fol_shape.outTranslate, fol.translate)
            fol.inheritsTransform.set(False)
            fol_shape.parameterU.set(0.5)
            fol_shape.parameterV.set(0.1 * count)
            fols.append(fol)
            fol_shapes.append(fol_shapes)
            count += 1

        nurbs_jnts = Chain.make_jnt_chain(
            fols, name_template="_surface_{number}_JNT")
        for nurbs_JNT, fol in zip(nurbs_jnts[0:], fols[:-1]):
            nurbs_JNT.setParent(fol)

        drivers = []
        driver_a_jnt = pm.duplicate(nurbs_jnts[0], name="driver_A")
        driver_b_jnt = pm.duplicate(nurbs_jnts[(spans / 2) - 1],
                                    name="driver_B")
        driver_c_jnt = pm.duplicate(nurbs_jnts[-1], name="driver_C")
        drivers.append(driver_a_jnt)
        drivers.append(driver_b_jnt)
        drivers.append(driver_c_jnt)
        pm.parent(drivers, w=True)
        for driver in drivers:
            pm.setAttr(driver[0] + ".radius", 1.5)
        pm.bindSkin(nurbs, drivers)
Exemple #26
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
Exemple #27
0
def create_surface_plane(align_to=None, axis='x', width=0.5, freeze_tm=True):
    """Create surface plane and return transform pynode of the surface plane.

    :key align_to: Target align of the newly created surface.
    :type align_to: pm.nt.Transform
    :key axis: Surface normal direction in 'x', 'y', 'z'. Default 'x'
    :type axis: str
    :key width: The width of the plane. Default: 0.5
    :type width: float
    :key freeze_tm: If True, freeze_transform operation will be applied to the newly created surface.
    :type freeze_tm: bool
    :rtype: pm.nt.Transform
    """
    axis_dict = {'x': (1, 0, 0), 'y': (0, 1, 0), 'z': (0, 0, 1)}
    res = pm.nurbsPlane(axis=axis_dict[axis],
                        width=width,
                        degree=1,
                        constructionHistory=False)[0]
    if align_to is not None:
        transformation.align(res, align_to)
    if freeze_tm:
        transformation.freeze_transform(res)
    return res
Exemple #28
0
    def rig_createDynamicChain(self, topNode=None): # Returns: [DynJoints], [DynControl], Transform(DynTopNode)
        ''' Create dynamic joint chain '''
        # Get the root locators
        rootLocs = pm.listRelatives('HairRig_MainCnt',children=True)[1:]

        # Per chain
        index = 0
        for chainName, numJnts in zip(self.chainNames, self.chainNumJnts):
            index = index + 1
            
            # Chain grp
            chainGrp = pm.group(n=chainName+'_dyn_grp', parent=topNode, em=True)
            pm.delete(pm.parentConstraint(rootLocs[index-1],chainGrp,mo=0))

            # Get locator names
            locNames = ['%s_loc%s'%(chainName,num) for num in range(int(numJnts)) if num != 0]
            locNames.insert(0,'%s_rootLoc'%chainName)

            # Get locator positions
            positions = []
            for loc in locNames:
                positions.append( pm.xform(loc,q=1,ws=1,t=1) )

            # Draw dynamic joint chain
            dynJnts = []
            pm.select(chainGrp,replace=True)
            for i in range(len(positions)):
                dynJnts.append(pm.joint(name=chainName+'_hr_dynJnt_%s'%i, p=positions[i]))
            
            # Draw curve along dynamic chain
            positions = []
            for jnt in dynJnts:
                positions.append(pm.xform(jnt,q=1,ws=1,rp=1))
            crv = pm.curve( name='chain%s_crv'%index, p=positions, d=1 )
            pm.rebuildCurve( crv, s=5 )
            pm.xform( crv, rp=positions[0], ws=True )
            pm.delete( crv, ch=True )
            pm.parent( crv, topNode )
            
            # Create root nurbs plane
            plane = pm.nurbsPlane( name='dynPlane_%s'%index, d=3, u=2, v=2, ax=[0,-1,0] )[0]
            pm.move(plane, float(positions[0][0]), float(positions[0][1]), float(positions[0][2]), a=1)
            pm.parent( plane, chainGrp )
            
            #Get data for current limb
            startJnt = pm.listRelatives( chainGrp, children=True )[0]
            pm.select(pm.listRelatives( chainGrp, children=True )[0], hi=True )
            endJnt = pm.ls(sl=1)[-1]

            # Make curve dynamic
            pm.select( plane, r=True )
            pm.select( crv, add=True )
            pm.mel.eval( 'makeCurvesDynamicHairs %d %d %d' % (1, 0, 1) )
            
            # Get names for hair system
            temp = pm.pickWalk( crv, d='up' )
            hairSystemName = 'hairSystem%s'%index
            dynCrv = pm.listRelatives( '%sOutputCurves'%hairSystemName,  children=True)[0]
            pm.rename(dynCrv,'dynCrv_%s'%index)
            dynCrv = 'dynCrv_%s'%index
            pm.parent( hairSystemName, chainGrp )
            
            # Make ik spline using dynamic curve
            handle, effector = pm.ikHandle( sj=startJnt, ee=endJnt, sol='ikSplineSolver', c=dynCrv, ccv=False )
            pm.parent( handle, chainGrp )
            
            # Clean up
            follicle = pm.listRelatives( crv, parent=True )[0]
            pm.parent( crv, 'HairRig_MainCnt' )
            pm.parent( follicle, chainGrp )
            pm.delete( '%sOutputCurves'%hairSystemName )
            
            pm.setAttr( '%s.visibility'%follicle, 0 )
            pm.setAttr( '%s.visibility'%crv, 0 )
            pm.setAttr( '%s.visibility'%dynCrv, 0 )
            pm.setAttr( '%s.visibility'%handle, 0 )
            pm.setAttr( '%s.visibility'%plane, 0 )
            pm.setAttr( '%s.visibility'%hairSystemName, 0 )
            
            # Create attributes on main control
            
        return dynJnts
    def test_createPlaneControls(self):
        fr = FollowRibbon.FollowRibbon(name="blah")
        plane = pm.nurbsPlane(axis=[0, 1, 0], patchesU=8, patchesV=1, lengthRatio=0.1, ch=0)[0]

        grps, jnts, cposNodes = fr._createPlaneControls(plane=plane, direction="u", number=6)

        self.testLib.assertListEqual(
            cposNodes,
            [
                "blah_drvCPOS_01",
                "blah_drvCPOS_02",
                "blah_drvCPOS_03",
                "blah_drvCPOS_04",
                "blah_drvCPOS_05",
                "blah_drvCPOS_06",
            ],
        )

        self.assertEqual(grps[0].name(), "blah_drvGrp_01")
        self.assertEqual(grps[1].name(), "blah_drvGrp_02")
        self.assertEqual(grps[2].name(), "blah_drvGrp_03")
        self.assertEqual(grps[3].name(), "blah_drvGrp_04")
        self.assertEqual(grps[4].name(), "blah_drvGrp_05")
        self.assertEqual(grps[5].name(), "blah_drvGrp_06")

        self.assertEqual(jnts[0].name(), "blah_drvJnt_01")
        self.assertEqual(jnts[1].name(), "blah_drvJnt_02")
        self.assertEqual(jnts[2].name(), "blah_drvJnt_03")
        self.assertEqual(jnts[3].name(), "blah_drvJnt_04")
        self.assertEqual(jnts[4].name(), "blah_drvJnt_05")
        self.assertEqual(jnts[5].name(), "blah_drvJnt_06")

        self.assertTrue(pm.objExists("blah_drvCPOS_01"))
        self.assertTrue(pm.objExists("blah_drvCPOS_02"))
        self.assertTrue(pm.objExists("blah_drvCPOS_03"))
        self.assertTrue(pm.objExists("blah_drvCPOS_04"))
        self.assertTrue(pm.objExists("blah_drvCPOS_05"))
        self.assertTrue(pm.objExists("blah_drvCPOS_06"))

        self.assertEqual(pm.getAttr("blah_drvCPOS_01.turnOnPercentage"), 1)

        self.assertEqual(pm.getAttr("blah_drvCPOS_01.parameterV"), 0.5)
        self.assertEqual(pm.getAttr("blah_drvCPOS_02.parameterV"), 0.5)
        self.assertEqual(pm.getAttr("blah_drvCPOS_03.parameterV"), 0.5)
        self.assertEqual(pm.getAttr("blah_drvCPOS_04.parameterV"), 0.5)
        self.assertEqual(pm.getAttr("blah_drvCPOS_05.parameterV"), 0.5)
        self.assertEqual(pm.getAttr("blah_drvCPOS_06.parameterV"), 0.5)

        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_01.parameterU"), 0)
        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_02.parameterU"), 0.2, 2)
        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_03.parameterU"), 0.4, 2)
        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_04.parameterU"), 0.6, 2)
        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_05.parameterU"), 0.8, 2)
        self.assertAlmostEquals(pm.getAttr("blah_drvCPOS_06.parameterU"), 1)

        self.assertTrue(pm.objExists("blah_drvGrp_01"))
        self.assertTrue(pm.objExists("blah_drvGrp_02"))
        self.assertTrue(pm.objExists("blah_drvGrp_03"))
        self.assertTrue(pm.objExists("blah_drvGrp_04"))
        self.assertTrue(pm.objExists("blah_drvGrp_05"))
        self.assertTrue(pm.objExists("blah_drvGrp_06"))

        self.assertTrue(pm.isConnected("blah_drvCPOS_01.position", "blah_drvGrp_01.translate"))
        self.assertTrue(pm.isConnected("blah_drvCPOS_02.position", "blah_drvGrp_02.translate"))
        self.assertTrue(pm.isConnected("blah_drvCPOS_03.position", "blah_drvGrp_03.translate"))
        self.assertTrue(pm.isConnected("blah_drvCPOS_04.position", "blah_drvGrp_04.translate"))
        self.assertTrue(pm.isConnected("blah_drvCPOS_05.position", "blah_drvGrp_05.translate"))
        self.assertTrue(pm.isConnected("blah_drvCPOS_06.position", "blah_drvGrp_06.translate"))

        self.assertTrue(pm.objExists("blah_drvJnt_01"))
        self.assertTrue(pm.objExists("blah_drvJnt_02"))
        self.assertTrue(pm.objExists("blah_drvJnt_03"))
        self.assertTrue(pm.objExists("blah_drvJnt_04"))
        self.assertTrue(pm.objExists("blah_drvJnt_05"))
        self.assertTrue(pm.objExists("blah_drvJnt_06"))

        self.assertEqual(pm.listRelatives("blah_drvJnt_01", parent=1)[0], "blah_drvGrp_01")
        self.assertEqual(pm.listRelatives("blah_drvJnt_02", parent=1)[0], "blah_drvGrp_02")
        self.assertEqual(pm.listRelatives("blah_drvJnt_03", parent=1)[0], "blah_drvGrp_03")
        self.assertEqual(pm.listRelatives("blah_drvJnt_04", parent=1)[0], "blah_drvGrp_04")
        self.assertEqual(pm.listRelatives("blah_drvJnt_05", parent=1)[0], "blah_drvGrp_05")
        self.assertEqual(pm.listRelatives("blah_drvJnt_06", parent=1)[0], "blah_drvGrp_06")
Exemple #30
0
def create_ribbon(numJoints=10, prefix='testRibbon', numSpans=5, startObj=None, endObj=None):
    rigGrp = pm.group(empty=True, name='%s_rig_grp' %prefix)

    ctrlGrp = pm.group(empty=True, name="%s_ctrl_grp" %prefix)
    
    proxyGrp = pm.group(empty=True, name="%s_proxy_grp" %prefix)
    
    ctrlGrp.overrideDisplayType.set(1) #template
    proxyGrp.visibility >> ctrlGrp.overrideEnabled           
    
    #===========================================================================
    # proxy
    #===========================================================================
    
    proxy_start = pm.spaceLocator(name='%s_root_start' %prefix)
    pm.parent( proxy_start.add_parent_group(suffix='const'), proxyGrp)
    
    proxy_end = pm.spaceLocator(name='%s_root_end' %prefix)
    proxy_end.tx.set(1)
    pm.parent( proxy_end.add_parent_group(suffix='const'), proxyGrp)
    
    #===========================================================================
    # proxy
    #===========================================================================
    rootCtrl = pm.spaceLocator(name='%s_root_ctrl' %prefix)
    pm.parent(pm.parentConstraint(proxy_start, rootCtrl, mo=False), proxyGrp)
    pm.parent(rootCtrl, ctrlGrp)
    
    proxy_up = pm.spaceLocator(name='%s_root_up' %prefix)
    proxy_up.ty.set(1)
    pm.parent( proxy_up.add_parent_group(suffix='const'), proxyGrp)
    
    proxy_mid = pm.spaceLocator(name='%s_root_mid' %prefix)
    proxy_mid.tx.set(1)
    proxy_mid_const = proxy_mid.add_parent_group(suffix='const')
    pm.parent( proxy_mid_const, proxyGrp)
    
    pm.pointConstraint(proxy_start, proxy_end, proxy_mid_const, mo=False)
    
    pm.aimConstraint(proxy_end, proxy_start, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name())
    pm.aimConstraint(proxy_start, proxy_end, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=proxy_up.name())
    
    pm.parentConstraint(rootCtrl, rigGrp, mo=False)

    #===========================================================================
    # ribbon plane
    #===========================================================================
    ribbonGrp = pm.group(empty=True, name="%s_ribbon_grp" %prefix)
    pm.parent(ribbonGrp, rigGrp)
    
    follicleGrp = pm.group(empty=True, name="%s_follicle_grp" %prefix)
    pm.parent(follicleGrp, rigGrp)
    follicleGrp.inheritsTransform.set(0)
    follicleGrp.overrideDisplayType.set(2) #reference
    proxyGrp.visibility >> follicleGrp.overrideEnabled       
    
    
    ribbonName = "%s_ribbon" %prefix
    
    ribbon = pm.nurbsPlane(ax=[0,1,0], w=1, lr=0.05, d=3, u=10, v=1, ch=0, name=ribbonName)[0]
    ribbon.translateX.set(0.5)
    ribbon.rotateX.set(90)
    pm.makeIdentity(ribbon, apply=True, t=1 ,r=1 ,s=1, n=0 ,pn=1)
    ribbon.scalePivot.set(0,0,0)
    ribbon.rotatePivot.set(0,0,0)
    
    pm.parent(ribbon, ribbonGrp)
    ribbonGrp.visibility.set(0)
    
    #proxy_start.rotateX >> ribbon.rotateX

    #===========================================================================
    # ribbon follicles / joints
    #===========================================================================
    joints = []
    proxyCubes = []
    
    spacing = (1.0/(numJoints-1))
    
    for i in range(numJoints):
        uPos = i * spacing

        jointName = "%s_%d" %(prefix, i+1)
        
        fol = create_follicle(ribbon, uPos, 0.5)
        fol_trans = fol.getParent()
    
        pm.select(clear=True)
        joint = pm.joint(name=jointName)
        
        #=======================================================================
        cube = pm.polyCube(w=spacing, h=spacing, d=spacing, ch=False)[0]
        pm.parentConstraint(joint, cube)
        pm.parent(cube, joint)
#         pm.parent(cube, proxyGrp)
        proxyCubes.append(cube)
        cube.overrideEnabled.set(1)
        cube.overrideDisplayType.set(2) #reference
        #=======================================================================
        
        pm.parent(joint, fol_trans, r=True)
        
        pm.parent(fol_trans, follicleGrp)
        
        joints.append(joint)

    #===========================================================================
    # ribbon wires
    #===========================================================================
    wireGrp = pm.group(empty=True, name="%s_wire_grp" %prefix)
    pm.parent(wireGrp, rigGrp)

    wireCtrlGrp = pm.group(empty=True, name='%s_wire_ctrl_grp' %prefix)
    pm.parent(wireCtrlGrp, rootCtrl)
    wireCtrlGrp.inheritsTransform.set(0)
    
    wireName = '%s_wire' %prefix
    
    wireCurve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name=wireName)
    mel.eval("rebuildCurve -ch 0 -rpo 1 -rt 0 -end 1 -kr 0 -kcp 0 -kep 1 -kt 0 -s %d -d 2 %s" %(numSpans, wireCurve.name()))

    wire2, wireCurve, wireBaseCurve = wire_deformer( wireCurve, ribbon)
    pm.parent(wireCurve, wireBaseCurve, wireGrp)

    #pm.reorderDeformers(wire1, wire2, ribbon)

    #===========================================================================
    # ribbon curve/ctrls 
    #===========================================================================
    curve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name="%s_curve"%prefix)
    pm.parent(curve, ribbonGrp)

    #wire1, curve, baseCurve = wire_deformer( curve, wireCurve)

    ctrls=[]
    
    for cv in curve.cv:
        clusterName = '%s_curve%d_cluster' %(prefix, cv.index())
        ctrlName = "%s_curve%d_ctrl" %(prefix, cv.index())
        
        cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName)
        clusterHandle.visibility.set(0)
        
        ctrl = pm.spaceLocator(name=ctrlName)
        pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False))

        pm.parentConstraint(ctrl, clusterHandle)
        
        ctrls.append(ctrl)
        
        pm.parent(clusterHandle, ribbonGrp)
    
    startCtrl = ctrls[0]
    midCtrl = ctrls[1]
    endCtrl = ctrls[-1]
         
    startCtrlName = "%s_start_ctrl" %prefix
    endCtrlName = "%s_end_ctrl" %prefix
     
    startCtrl.rename("%s_start_ctrl" %prefix)
    startConst = startCtrl.add_parent_group(suffix='const')
    pm.parent(pm.parentConstraint(proxy_start, startConst, mo=False), proxyGrp)
     
    endCtrl.rename("%s_end_ctrl" %prefix)
    endConst = endCtrl.add_parent_group(suffix='const')
    pm.parent(pm.parentConstraint(proxy_end, endConst, mo=False), proxyGrp)
    
    midCtrl.rename("%s_mid_ctrl" %prefix)
    midConst = midCtrl.add_parent_group(suffix='const')
    pm.parent(pm.parentConstraint(proxy_mid, midConst, mo=False), proxyGrp)

    startCtrl.getShape().localPositionX.set(-1)
    endCtrl.getShape().localPositionX.set(1)    
     
    pm.parent(startConst, endConst, midConst, rootCtrl)

    #===========================================================================
    # ribbon wire cluster
    #===========================================================================
    for cv in wireCurve.cv:
        #cluster / ctrl
        clusterName = '%s_wire%d_cluster' %(prefix, cv.index())
        ctrlName = "%s_wire%d_ctrl" %(prefix, cv.index())
        
        cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName)
        
        ctrl = pm.spaceLocator(name=ctrlName)
        pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False))

        pm.parentConstraint(ctrl, clusterHandle)
        pm.scaleConstraint(ctrl, clusterHandle)
        #ctrl.t >> clusterHandle.t
        #ctrl.r >> clusterHandle.r
        #ctrl.s >> clusterHandle.s
        
        ctrls.append(ctrl)
        
        pm.parent(clusterHandle, wireGrp)
        
        #revit
        revit = pm.spaceLocator(name="%s_revit" %ctrl.name())
        revit.getShape().localScale.set(0,0,0)
        
        pm.delete(pm.parentConstraint(ctrl, revit, mo=False))
        pm.parent(ctrl, revit)
        
        revit_locator_to_curve(revit, curve)
        rootCtrl.r >> revit.r
                
        pm.parent(revit, wireCtrlGrp)

    wireGrp.visibility.set(0)
         
    #===========================================================================
    # twist
    #===========================================================================
    twistGrp = pm.group(empty=True, name="%s_twist_grp" %prefix)
    pm.parent(twistGrp, rigGrp)    
      
    startTwist = pm.group(empty=True, name="%s_start_twist" %prefix)
    startTwistAim = startTwist.add_parent_group(suffix='aim')    
    pm.pointConstraint(startCtrl, startTwistAim, mo=False)
  
    endTwist = pm.group(empty=True, name="%s_end_twist" %prefix)
    endTwistAim = endTwist.add_parent_group(suffix='aim')    
    pm.pointConstraint(endCtrl, endTwistAim, mo=False)
      
    startTwistUp = pm.spaceLocator(name="%s_start_twistUp" %prefix)
    pm.delete(pm.parentConstraint(startCtrl, startTwistUp, mo=False))
    startTwistUp.ty.set(1)
    pm.parentConstraint(startCtrl, startTwistUp, mo=True)
      
    endTwistUp = pm.spaceLocator(name="%s_end_twistUp" %prefix)
    pm.parentConstraint(endCtrl, endTwistUp, mo=False)
    endTwistUp.ty.set(1)
    const = pm.parentConstraint(endCtrl, endTwistUp, mo=True)
  
    pm.aimConstraint(endTwistAim, startTwistAim, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=startCtrl.name())
    pm.aimConstraint(startTwistAim, endTwistAim, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='objectrotation', worldUpVector=[0,1,0], worldUpObject=endCtrl.name())
   
    #pm.aimConstraint(endTwist, startTwist, aimVector=[1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=startTwistUp.name())
    #pm.aimConstraint(startTwist, endTwist, aimVector=[-1,0,0], upVector=[0,1,0], worldUpType='object', worldUpObject=endTwistUp.name())
       
    twist, twistHdl = pm.nonLinear(ribbon , type='twist', foc=True, name='%s_twist'%prefix)
    twistHdl.rotateZ.set(90)
     
    startTwistAim.rx >> twist.endAngle
    endTwistAim.rx >> twist.startAngle     
       
    #startTwist.rx >> twist.endAngle
    #endTwist.rx >> twist.startAngle
       
    pm.parent(startTwistUp, endTwistUp, twistHdl, startTwistAim, endTwistAim, twistGrp)
    twistGrp.visibility.set(0)
   
    #===========================================================================
    # stretch and squash
    #===========================================================================
    stretchGrp = pm.group(empty=True, name="%s_stretch_grp" %prefix)
    stretchGrp.addAttr('baseDistance', at='double')
    pm.parent(stretchGrp, rigGrp)
    stretchGrp.inheritsTransform.set(0)
         
    stretchPlane = pm.nurbsPlane(ax=[0,1,0], ch=False, w=2, lr=1, d=3, u=2, v=2, name='%s_stretch_plane'%prefix)
    squash, squashHdl = pm.nonLinear(stretchPlane, type='squash', foc=True, name="%s_squash"%prefix)
    squashHdl.rotateZ.set(90)
         
    for i in range(numJoints):
        spacing = i * (1.0/(numJoints-1))
             
        pointOnSurface = pm.createNode('pointOnSurfaceInfo')
        stretchPlane[0].getShape().worldSpace[0] >> pointOnSurface.inputSurface
             
        pointOnSurface.parameterU.set(spacing)
             
        pointOnSurface.positionZ >> joints[i].sz
        pointOnSurface.positionZ >> joints[i].sy
             
    baseDistance = pm.createNode('distanceBetween', name="%s_base_distance" %prefix)
    proxy_start.getShape().worldPosition[0] >> baseDistance.point1
    proxy_end.getShape().worldPosition[0] >> baseDistance.point2
         
    stretchDistance = pm.createNode('distanceBetween', name="%s_stretch_distance" %prefix)
         
    stretchDistanceStart = pm.spaceLocator(name="%s_stretch_distance_start" %prefix)
    stretchDistanceStart.localScale.set(0,0,0)
    pm.parentConstraint(startCtrl, stretchDistanceStart, mo=False)
         
    stretchDistanceEnd = pm.spaceLocator(name="%s_stretch_distance_end" %prefix)
    stretchDistanceEnd.localScale.set(0,0,0)
    pm.parentConstraint(endCtrl, stretchDistanceEnd, mo=False)
         
    stretchDistanceStart.getShape().worldPosition[0] >> stretchDistance.point1
    stretchDistanceEnd.getShape().worldPosition[0] >> stretchDistance.point2
         
    strechFactor_md = pm.createNode('multiplyDivide', name='%s_stretch_distance_md' %prefix)
    strechFactor_md.operation.set(2) #divide
    baseDistance.distance >> stretchGrp.baseDistance 
         
    stretchGrp.baseDistance >> strechFactor_md.input2X
    stretchDistance.distance >> strechFactor_md.input1X
         
    strechFactor_remap = pm.createNode('remapValue', name="%s_stretch_factor_remap" %prefix)
    strechFactor_md.outputX >> strechFactor_remap.inputValue
         
    strechFactor_remap.inputMin.set(0.5)
    strechFactor_remap.inputMax.set(1.5)
    strechFactor_remap.outputMin.set(-1)
    strechFactor_remap.outputMax.set(1)
         
    strechFactor_remap.outValue >> squash.factor
         
    pm.parent(stretchDistanceStart, stretchDistanceEnd, stretchPlane, squashHdl, stretchGrp)
    
    stretchGrp.visibility.set(0)
    
    #===========================================================================
    for cube in proxyCubes:
        stretchGrp.baseDistance >> cube.sx
        stretchGrp.baseDistance >> cube.sy
        stretchGrp.baseDistance >> cube.sz

    stretchGrp.baseDistance >> ribbon.sz        
    
    #===========================================================================
         

    #===========================================================================
    # Positioning
    #===========================================================================
    if startObj and endObj:
        pm.delete(pm.parentConstraint(startObj, proxy_start, mo=False))
        pm.delete(pm.parentConstraint(endObj, proxy_end, mo=False))
        
        pm.delete(pm.parentConstraint(startObj, proxy_up, mo=False))
        proxy_up.ty.set(proxy_up.ty.get() + 1)        
    
                  
                          
    def create_surface(self, name='Surface', epsilon=0.001, default_scale=1.0):
        """
        Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide
        a surface for the influence to slide on.
        :param name: The suffix of the surface name to create.
        :return: A pymel.nodetypes.Transform instance of the created surface.
        """
        nomenclature = self.get_nomenclature_rig().copy()
        nomenclature.add_tokens(name)

        root = pymel.createNode('transform')
        pymel.addAttr(root, longName='bendUpp', k=True)
        pymel.addAttr(root, longName='bendLow', k=True)
        pymel.addAttr(root, longName='bendSide', k=True)

        # Create Guide
        plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4)

        # Create Bends
        bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform, type='bend')
        bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform, type='bend')
        bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform, type='bend')

        plane_transform.r.set(0, -90, 0)
        bend_side_handle.r.set(90, 90, 0)
        bend_upp_handle.r.set(180, 90, 0)
        bend_low_handle.r.set(180, 90, 0)
        bend_upp_deformer.highBound.set(0)  # create pymel warning
        bend_low_deformer.lowBound.set(0)  # create pymel warning

        plane_transform.setParent(root)
        bend_side_handle.setParent(root)
        bend_upp_handle.setParent(root)
        bend_low_handle.setParent(root)

        pymel.connectAttr(root.bendSide, bend_side_deformer.curvature)
        pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature)
        pymel.connectAttr(root.bendLow, bend_low_deformer.curvature)

        # Rename all the things!
        root.rename(nomenclature.resolve('SurfaceGrp'))
        plane_transform.rename(nomenclature.resolve('Surface'))
        bend_upp_deformer.rename(nomenclature.resolve('UppBend'))
        bend_low_deformer.rename(nomenclature.resolve('LowBend'))
        bend_side_deformer.rename(nomenclature.resolve('SideBend'))
        bend_upp_handle.rename(nomenclature.resolve('UppBendHandle'))
        bend_low_handle.rename(nomenclature.resolve('LowBendHandle'))
        bend_side_handle.rename(nomenclature.resolve('SideBendHandle'))

        # Try to guess the desired position
        min_x = None
        max_x = None
        pos = pymel.datatypes.Vector()
        for jnt in self.jnts:
            pos += jnt.getTranslation(space='world')
            if min_x is None or pos.x < min_x:
                min_x = pos.x
            if max_x is None or pos.x > max_x:
                max_x = pos.x
        pos /= len(self.jnts)
        root.setTranslation(pos)

        # Try to guess the scale
        length_x = max_x - min_x
        if len(self.jnts) <= 1 or length_x < epsilon:
            log.debug("Cannot automatically resolve scale for surface. Using default value {0}".format(default_scale))
            length_x = default_scale

        root.scaleX.set(length_x)
        root.scaleY.set(length_x * 0.5)
        root.scaleZ.set(length_x)

        pymel.select(root)

        # self.input.append(plane_transform)

        return plane_transform
Exemple #32
0
    def rig_createDynamicChain(
        self,
        topNode=None
    ):  # Returns: [DynJoints], [DynControl], Transform(DynTopNode)
        ''' Create dynamic joint chain '''
        # Get the root locators
        rootLocs = pm.listRelatives('HairRig_MainCnt', children=True)[1:]

        # Per chain
        index = 0
        for chainName, numJnts in zip(self.chainNames, self.chainNumJnts):
            index = index + 1

            # Chain grp
            chainGrp = pm.group(n=chainName + '_dyn_grp',
                                parent=topNode,
                                em=True)
            pm.delete(pm.parentConstraint(rootLocs[index - 1], chainGrp, mo=0))

            # Get locator names
            locNames = [
                '%s_loc%s' % (chainName, num) for num in range(int(numJnts))
                if num != 0
            ]
            locNames.insert(0, '%s_rootLoc' % chainName)

            # Get locator positions
            positions = []
            for loc in locNames:
                positions.append(pm.xform(loc, q=1, ws=1, t=1))

            # Draw dynamic joint chain
            dynJnts = []
            pm.select(chainGrp, replace=True)
            for i in range(len(positions)):
                dynJnts.append(
                    pm.joint(name=chainName + '_hr_dynJnt_%s' % i,
                             p=positions[i]))

            # Draw curve along dynamic chain
            positions = []
            for jnt in dynJnts:
                positions.append(pm.xform(jnt, q=1, ws=1, rp=1))
            crv = pm.curve(name='chain%s_crv' % index, p=positions, d=1)
            pm.rebuildCurve(crv, s=5)
            pm.xform(crv, rp=positions[0], ws=True)
            pm.delete(crv, ch=True)
            pm.parent(crv, topNode)

            # Create root nurbs plane
            plane = pm.nurbsPlane(name='dynPlane_%s' % index,
                                  d=3,
                                  u=2,
                                  v=2,
                                  ax=[0, -1, 0])[0]
            pm.move(plane,
                    float(positions[0][0]),
                    float(positions[0][1]),
                    float(positions[0][2]),
                    a=1)
            pm.parent(plane, chainGrp)

            #Get data for current limb
            startJnt = pm.listRelatives(chainGrp, children=True)[0]
            pm.select(pm.listRelatives(chainGrp, children=True)[0], hi=True)
            endJnt = pm.ls(sl=1)[-1]

            # Make curve dynamic
            pm.select(plane, r=True)
            pm.select(crv, add=True)
            pm.mel.eval('makeCurvesDynamicHairs %d %d %d' % (1, 0, 1))

            # Get names for hair system
            temp = pm.pickWalk(crv, d='up')
            hairSystemName = 'hairSystem%s' % index
            dynCrv = pm.listRelatives('%sOutputCurves' % hairSystemName,
                                      children=True)[0]
            pm.rename(dynCrv, 'dynCrv_%s' % index)
            dynCrv = 'dynCrv_%s' % index
            pm.parent(hairSystemName, chainGrp)

            # Make ik spline using dynamic curve
            handle, effector = pm.ikHandle(sj=startJnt,
                                           ee=endJnt,
                                           sol='ikSplineSolver',
                                           c=dynCrv,
                                           ccv=False)
            pm.parent(handle, chainGrp)

            # Clean up
            follicle = pm.listRelatives(crv, parent=True)[0]
            pm.parent(crv, 'HairRig_MainCnt')
            pm.parent(follicle, chainGrp)
            pm.delete('%sOutputCurves' % hairSystemName)

            pm.setAttr('%s.visibility' % follicle, 0)
            pm.setAttr('%s.visibility' % crv, 0)
            pm.setAttr('%s.visibility' % dynCrv, 0)
            pm.setAttr('%s.visibility' % handle, 0)
            pm.setAttr('%s.visibility' % plane, 0)
            pm.setAttr('%s.visibility' % hairSystemName, 0)

            # Create attributes on main control

        return dynJnts
Exemple #33
0
def makeCard(jointCount=5,
             jointNames={'repeat': 'DEFAULT'},
             rigInfo=None,
             size=(4, 6),
             suffix=''):
    '''
    ..  todo:: Do not use defaults.
    
    &&& names is really joints names, make it so.
    '''
    if isinstance(jointNames, basestring):
        head, repeat, tail = util.parse(jointNames)
        jointNames = {'head': head, 'repeat': repeat, 'tail': tail}

    elif isinstance(jointNames, list):
        jointNames = {'head': jointNames}

    leadName = jointNames.get('head')[0] if jointNames.get(
        'head') else jointNames.get('repeat', 'DEFAULT')

    joints = []
    width, height = size

    # Base the card name off the lead joint
    cardName = leadName

    if not isinstance(cardName, basestring):
        cardName = cardName[0]
        #jointNames = ' '.join(jointNames)

    if not cardName.endswith('_card'):
        if cardName.endswith('_'):
            cardName += 'card'
        else:
            cardName += '_card'

    # Make the actual card and tag with attrs
    card = nurbsPlane(w=width,
                      lr=height / float(width),
                      ax=(1, 0, 0),
                      n=cardName,
                      d=1,
                      u=1,
                      v=1)[0]

    card.addAttr('moRigData', dt='string')
    card.addAttr('moRigState', dt='string')

    addOutputControlsAttrs(card)
    addJointArrayAttr(card)

    #card.addAttr( 'skeletonInfo', at='bool' )
    #card.addAttr( 'buildOrder', at='long' )
    #card.addAttr( 'nameInfo', dt='string' )
    #card.addAttr( 'suffix', dt='string' )

    # Reassign it so it gets the proper interface now that it has the attrs
    card = PyNode(card)

    rigData = {
        'buildOrder': 10,
        'mirrorCode': suffix,
        'nameInfo': jointNames,
    }

    card.rigData = rigData

    #card.buildOrder.set( 10 )
    #card.suffix.set( suffix )
    #card.nameInfo.set( jointNames ) # &&& I hate how I handle the names, want to put in rigInfo (I think that's the json attr...)

    #card.rigParams = ''
    #card.rigOptions = ''

    arrow = makeArrow()
    arrow.setParent(card)
    arrow.rename('arrow')
    card.scale >> arrow.inverseScale

    arrow.t.set(0, 0, 0)
    arrow.r.set(0, 0, -90)
    hide(arrow)
    card.setParent(proxy.masterGroup())

    # Place all the joints

    delta = height / float(jointCount - 1) if jointCount > 1 else 0

    for i in range(jointCount):
        newJoint = card.addJoint()
        joints.append(newJoint)
        newJoint.ty.set(height / 2.0 - delta * i)

    if len(joints) > 1:
        for parentBpj, childBpj in zip(joints[0:-1], joints[1:]):
            proxy.pointer(parentBpj, childBpj)
    elif joints:
        proxy.makeProxy(joints[0], proxy.getProxyGroup())
        joints[0].ty.set(0)

    if joints:
        card.setTempNames()

        pivToStart(card)

    return card
Exemple #34
0
def create_ribbon(numJoints=5, prefix='testRibbon', degree=None, spans=None ):
    rigGrp = pm.group(empty=True, name='%s_rig_grp' %prefix)
    root = pm.spaceLocator(name='%s_root' %prefix)


    #===========================================================================
    # ribbon plane
    #===========================================================================
    ribbonName = "%s_ribbon" %prefix
    
    ribbon = pm.nurbsPlane(ax=[0,1,0], w=1, lr=0.05, d=3, u=10, v=1, ch=0, name=ribbonName)[0]
    ribbon.translateX.set(0.5)
    pm.makeIdentity(ribbon, apply=True, t=1 ,r=1 ,s=1, n=0 ,pn=1)
    
    pm.parent(ribbon, rigGrp)

    #===========================================================================
    # ribbon follicles / joints
    #===========================================================================
    for i in range(numJoints):
        spacing = i * (1.0/(numJoints-1))

        jointName = "%s_%d" %(prefix, i+1)
        
        fol = create_follicle(ribbon, spacing, 0.5)
        fol_trans = fol.getParent()
    
        pm.select(clear=True)        
        joint = pm.joint(name=jointName)
        pm.parent(joint, fol_trans, r=True)
        
        pm.parent(fol, rigGrp)

    #===========================================================================
    # ribbon wires
    #===========================================================================
    curveName = '%s_wire' %prefix

    curve = pm.curve(d=2, p=[[0,0,0],[0.5,0,0],[1,0,0]], k=[0,0,1,1], name=curveName)
    if spans and degree:
        mel.eval("rebuildCurve -ch 0 -rpo 1 -rt 0 -end 1 -kr 0 -kcp 0 -kep 1 -kt 0 -s %d -d %d %s" %(spans, degree, curve.name()))

    wires = wire_deformer( curve.name(), ribbon.name())
    pm.parent(wires, rigGrp)
        
    #===========================================================================
    # ribbon wire control
    #===========================================================================
    ctrls = []
    for cv in curve.cv:
        clusterName = '%s_wire%d_cluster' %(prefix, cv.index())
        ctrlName = "%s_wire%d_ctrl" %(prefix, cv.index())
        
        cluster, clusterHandle = pm.cluster(cv, relative=True, name=clusterName)
        
        ctrl = pm.spaceLocator(name=ctrlName)
        pm.delete(pm.pointConstraint(clusterHandle, ctrl, mo=False))

        pm.parentConstraint(ctrl, clusterHandle)
        
        ctrls.append(ctrl)
        
        pm.parent(clusterHandle, rigGrp)

    #===========================================================================
    # ribbon start/end ctrls 
    #===========================================================================
    
    startCtrlName = "%s_start_ctrl" %prefix
    endCtrlName = "%s_end_ctrl" %prefix
    
    ctrls[0].rename(startCtrlName)
    startConst = ctrls[0].add_parentGroup(suffix='const')
    
    
    ctrls[-1].rename(endCtrlName)
    endConst = ctrls[-1].add_parentGroup(suffix='const')        
    
    pm.parent(startConst, endConst, root)

    #===========================================================================
    # mid ctrls
    #===========================================================================
    for ctrl in ctrls[1:-1]:
        value = ctrl.translateX.get()
        ctrlConst = ctrl.add_parentGroup(suffix='const')        
                
        pm.parentConstraint(ctrls[-1], ctrlConst, w=value)
        pm.parentConstraint(ctrls[0], ctrlConst, w=1-value)
        
        pm.parent(ctrlConst, root)
Exemple #35
0
    def create_surface(self, name='Surface'):
        """
        Create a simple rig to deform a nurbsSurface, allowing the rigger to easily provide
        a surface for the influence to slide on.
        :param name: The suffix of the surface name to create.
        :return: A pymel.nodetypes.Transform instance of the created surface.
        """
        nomenclature = self.get_nomenclature_rig().copy()
        nomenclature.add_tokens(name)

        root = pymel.createNode('transform')
        pymel.addAttr(root, longName='bendUpp', k=True)
        pymel.addAttr(root, longName='bendLow', k=True)
        pymel.addAttr(root, longName='bendSide', k=True)

        # Create Guide
        plane_transform, plane_make = pymel.nurbsPlane(patchesU=4, patchesV=4)

        # Create Bends
        bend_side_deformer, bend_side_handle = pymel.nonLinear(plane_transform,
                                                               type='bend')
        bend_upp_deformer, bend_upp_handle = pymel.nonLinear(plane_transform,
                                                             type='bend')
        bend_low_deformer, bend_low_handle = pymel.nonLinear(plane_transform,
                                                             type='bend')

        plane_transform.r.set(0, -90, 0)
        bend_side_handle.r.set(90, 90, 0)
        bend_upp_handle.r.set(180, 90, 0)
        bend_low_handle.r.set(180, 90, 0)
        bend_upp_deformer.highBound.set(0)  # create pymel warning
        bend_low_deformer.lowBound.set(0)  # create pymel warning

        plane_transform.setParent(root)
        bend_side_handle.setParent(root)
        bend_upp_handle.setParent(root)
        bend_low_handle.setParent(root)

        pymel.connectAttr(root.bendSide, bend_side_deformer.curvature)
        pymel.connectAttr(root.bendUpp, bend_upp_deformer.curvature)
        pymel.connectAttr(root.bendLow, bend_low_deformer.curvature)

        # Rename all the things!
        root.rename(nomenclature.resolve('SurfaceGrp'))
        plane_transform.rename(nomenclature.resolve('Surface'))
        bend_upp_deformer.rename(nomenclature.resolve('UppBend'))
        bend_low_deformer.rename(nomenclature.resolve('LowBend'))
        bend_side_deformer.rename(nomenclature.resolve('SideBend'))
        bend_upp_handle.rename(nomenclature.resolve('UppBendHandle'))
        bend_low_handle.rename(nomenclature.resolve('LowBendHandle'))
        bend_side_handle.rename(nomenclature.resolve('SideBendHandle'))

        # Try to guess the desired position
        min_x = None
        max_x = None
        pos = pymel.datatypes.Vector()
        for jnt in self.jnts:
            pos += jnt.getTranslation(space='world')
            if min_x is None or pos.x < min_x:
                min_x = pos.x
            if max_x is None or pos.x > max_x:
                max_x = pos.x
        pos /= len(self.jnts)

        length_x = max_x - min_x
        root.setTranslation(pos)
        root.scaleX.set(length_x)
        root.scaleY.set(length_x * 0.5)
        root.scaleZ.set(length_x)

        pymel.select(root)

        #self.input.append(plane_transform)

        return plane_transform
Exemple #36
0
def CreateSurface(pos1, pos2, Div=10):

    try:
        pm.select(pos1)
        tempPos = pm.cluster(n='Temp')[1]
        JntPos1 = pm.createNode('joint', n=(pos1 + '_Pos1Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos1))
        pm.makeIdentity(JntPos1, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    except:
        tempPos = pm.createNode('transform', n='Temp')
        pm.delete(pm.parentConstraint(pos1, tempPos))
        JntPos1 = pm.createNode('joint', n=(pos1 + '_Pos1Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos1))
        pm.makeIdentity(JntPos1, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    try:
        pm.select(pos2)
        tempPos = pm.cluster(n='Temp')[1]
        JntPos2 = pm.createNode('joint', n=(pos2 + '_Pos2Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos2))
        pm.makeIdentity(JntPos2, a=1, t=1, r=1, s=1)

        pm.delete(tempPos)

    except:
        tempPos = pm.createNode('transform', n='Temp')
        pm.delete(pm.parentConstraint(pos2, tempPos))
        JntPos2 = pm.createNode('joint', n=(pos2 + '_Pos2Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos2))
        pm.makeIdentity(JntPos2, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    pm.parent(JntPos2, JntPos1)

    pm.joint(JntPos1, e=1, oj='xyz', secondaryAxisOrient='yup')
    pm.joint(JntPos2, e=1, oj='none', ch=1, zso=1)

    distanceND = pm.createNode('distanceBetween')

    JntPos1.worldMatrix[0] >> distanceND.inMatrix1
    JntPos2.worldMatrix[0] >> distanceND.inMatrix2
    Dist = distanceND.distance.get()

    surface = pm.nurbsPlane(w=Dist, lr=.01, u=Div, ax=(0, 1, 0), ch=0)
    print surface
    bsSurface = pm.duplicate(surface)
    print bsSurface
    pm.blendShape(bsSurface,
                  surface,
                  foc=1,
                  n=(str(bsSurface[0]) + '_Blendshape'),
                  w=(0, 1))
    pm.delete(pm.parentConstraint(JntPos1, JntPos2, surface[0]))
    pm.delete(JntPos1, JntPos2)
    fols = []
    ctrls = []
    for i in range(0, Div):
        val = ((.5 / float(Div)) * (i + 1) * 2) - ((.5 / float(Div * 2)) * 2)

        fol = pm.createNode('transform',
                            n=('Tst_' + str(i) + '_Follicle'),
                            ss=1)
        folShape = pm.createNode('follicle',
                                 n=fol.name() + 'Shape',
                                 p=fol,
                                 ss=1)
        geo = surface[0]
        geo.local >> folShape.inputSurface
        geo.worldMatrix[0] >> folShape.inputWorldMatrix
        folShape.outRotate >> fol.rotate
        folShape.outTranslate >> fol.translate
        fol.inheritsTransform.set(False)
        folShape.parameterV.set(0.5)
        folShape.parameterU.set(val)
        fols.append(fol)
        Ctrl = mel.eval(
            "sphere -esw 360 -r 0.3 -d 1 -ut 0 -tol 0.01 -s 4 -nsp 2 -ch 0;")
        pm.PyNode(Ctrl[0])
        Ctrl = pm.rename(Ctrl[0], 'Follicle_' + str(i) + '_Ctrl')
        pm.delete(pm.parentConstraint(fol, Ctrl))
        Grp = ZeroOut(Ctrl)
        ctrls.append(Ctrl)

        try:
            Shaps = pm.listRelatives(Ctrl, s=1)[0]
            Shaps.overrideEnabled.set(1)
            Shaps.overrideShading.set(0)
            Shaps.overrideColor.set(4)
            Shaps.overrideEnabled.lock(True)
            Shaps.overrideShading.lock(True)
            Shaps.overrideColor.lock(True)
        except:
            pass
        pm.select(cl=1)
        pm.parent(Grp, fol)
        RevGrp = RevGroup(Ctrl)

    SknJnts = []
    for i in range(0, Div):
        val = ((.5 / float(Div)) * (i + 1) * 2) - ((.5 / float(Div * 2)) * 2)

        fol = pm.createNode('transform', n=('Tst_' + str(i)), ss=1)
        folShape = pm.createNode('follicle',
                                 n=fol.name() + 'Shape',
                                 p=fol,
                                 ss=1)
        geo = bsSurface[0]
        geo.local >> folShape.inputSurface
        geo.worldMatrix[0] >> folShape.inputWorldMatrix
        folShape.outRotate >> fol.rotate
        folShape.outTranslate >> fol.translate
        fol.inheritsTransform.set(False)
        folShape.parameterV.set(0.5)
        folShape.parameterU.set(val)
        pm.select(cl=1)
        jnt = pm.joint(n=('Follicle_' + str(i) + '_Jnt'))
        SknJnts.append(jnt)
        pm.delete(pm.parentConstraint(fol, jnt))
        #pm.delete(fol)
        ZeroOut(jnt)
        pm.makeIdentity(jnt, a=1, t=1, r=1, s=1)

    for i in range(0, Div):
        ctrls[i].t >> SknJnts[i].t
        ctrls[i].r >> SknJnts[i].r
        ctrls[i].s >> SknJnts[i].s

    pm.skinCluster(SknJnts, bsSurface, mi=3, omi=0, tsb=1, dr=10)
def super_ribbon(start='', end='', segments=5, ribbonName='ribbon'):
    ribbon_rootName = ribbonName  #+'_RBN'
    ribbon_distance_measure = pm.shadingNode('distanceBetween',
                                             name=ribbon_rootName +
                                             '_distance',
                                             asUtility=True)
    start_matrix = pm.shadingNode('decomposeMatrix',
                                  name=ribbon_rootName + '_start_matrix',
                                  asUtility=True)
    end_matrix = pm.shadingNode('decomposeMatrix',
                                name=ribbon_rootName + '_end_matrix',
                                asUtility=True)
    pm.connectAttr(start + '.worldMatrix', start_matrix + '.inputMatrix')
    pm.connectAttr(start_matrix + '.outputTranslate',
                   ribbon_distance_measure + '.point1')
    pm.connectAttr(end + '.worldMatrix', end_matrix + '.inputMatrix')
    pm.connectAttr(end_matrix + '.outputTranslate',
                   ribbon_distance_measure + '.point2')
    ribbon_length = pm.getAttr(ribbon_distance_measure + '.distance')
    ribbon_length_ratio = ribbon_length / (ribbon_length * segments)
    ribbonGEO = pm.nurbsPlane(name=ribbon_rootName + '_GEO',
                              axis=[0, 1, 0],
                              width=ribbon_length,
                              lengthRatio=ribbon_length_ratio,
                              degree=3,
                              patchesU=segments,
                              patchesV=1,
                              constructionHistory=0)
    ribbonGEO = ribbonGEO[0]
    pm.addAttr(ribbonGEO, longName='metaParent', attributeType='message')
    pm.addAttr(ribbonGEO,
               shortName='rbn',
               longName='ribbon',
               attributeType='message')
    ribbon_rootGRP = pm.group(name=ribbon_rootName + '_GRP')
    pm.addAttr(ribbon_rootGRP, longName='metaParent', attributeType='message')
    pm.addAttr(ribbon_rootGRP,
               shortName='rbn',
               longName='ribbon',
               attributeType='message')  ##---- connect with tagger
    pm.addAttr(ribbon_rootGRP,
               longName='ribbonSegments',
               attributeType='long',
               defaultValue=segments)
    pm.addAttr(ribbon_rootGRP, longName='rigPart', attributeType='message')
    ribbon_rootGRP.metaParent >> ribbonGEO.metaParent
    print 'making ribbon drive joints'
    #connect to face rig or lower face, whatever is the closest rig part
    startJointTrans = pm.xform(start, q=True, ws=True, translation=True)
    endJointTrans = pm.xform(end, q=True, ws=True, translation=True)
    midJointTrans = uf.average_position(start, end)

    drive_joint_list = []
    ##pm.setAttr(jointName + '.drawStyle' = 2) hide joints
    pm.select(clear=True)
    startJoint = pm.joint(name=ribbonName + '_RBN_start_DRV',
                          relative=True,
                          radius=2,
                          position=startJointTrans)
    pm.addAttr(startJoint, longName='metaParent', attributeType='message')
    pm.addAttr(startJoint,
               shortName='rbn',
               longName='ribbon',
               attributeType='message')
    pm.makeIdentity(startJoint, apply=True, rotate=True)
    drive_joint_list = drive_joint_list + [startJoint]
    ribbon_rootGRP.metaParent >> startJoint.metaParent
    pm.select(clear=True)
    endJoint = pm.joint(name=ribbonName + '_RBN_end_DRV',
                        relative=True,
                        radius=2,
                        position=endJointTrans)
    pm.addAttr(endJoint, longName='metaParent', attributeType='message')
    pm.addAttr(endJoint, longName='ribbon', attributeType='message')
    pm.makeIdentity(endJoint, apply=True, rotate=True)
    drive_joint_list = drive_joint_list + [endJoint]
    ribbon_rootGRP.metaParent >> endJoint.metaParent
    pm.select(clear=True)
    midJoint = pm.joint(name=ribbonName + '_RBN_mid_DRV',
                        relative=True,
                        radius=2,
                        position=midJointTrans)
    pm.addAttr(midJoint, longName='metaParent', attributeType='message')
    pm.addAttr(midJoint,
               shortName='rbn',
               longName='ribbon',
               attributeType='message')
    drive_joint_list = drive_joint_list + [midJoint]
    ribbon_rootGRP.metaParent >> midJoint.metaParent
    driver_group = uf.nest_transform(name=ribbon_rootName + '_drivers_GRP',
                                     action='parent',
                                     target=midJoint,
                                     transformObj='group')
    driver_group | startJoint
    driver_group | endJoint
    pm.select(clear=True)

    for driver in drive_joint_list:
        current_group_name = str(driver).replace('_DRV', '_GRP')
        current_group = uf.nest_transform(name=current_group_name,
                                          action='parent',
                                          target=driver,
                                          transformObj='group')
        current_offset = uf.nest_transform(name=current_group_name.replace(
            'GRP', 'OST'),
                                           action='parent',
                                           target=driver,
                                           transformObj='group')
    pm.select(clear=True)
    #move everything into position
    pm.xform(ribbon_rootGRP, translation=midJointTrans, worldSpace=True)
    ##---- skin to nurbs curve
    pm.select(drive_joint_list, ribbonGEO)
    pm.skinCluster(toSelectedBones=True,
                   bindMethod=0,
                   normalizeWeights=1,
                   weightDistribution=0,
                   maximumInfluences=2,
                   obeyMaxInfluences=True,
                   skinMethod=1,
                   dropoffRate=2,
                   removeUnusedInfluence=False)
    ##----
    # Propagate follicles
    print('making follicles and skin joints')
    follicle_list = []
    ribbon_locator_list = []
    current_name = ''
    for i in range(segments):
        uPosition_factor = 1 / float(segments)
        currentUposition = uPosition_factor * (float(i) + 0.5)
        print 'follicle'
        last_follicle = create_follicle(oNurbs=ribbonGEO,
                                        uPos=currentUposition,
                                        vPos=0.5)
        print('last follicle = ' + last_follicle.getParent())
        pm.addAttr(last_follicle,
                   longName='metaParent',
                   attributeType='message')
        pm.addAttr(last_follicle,
                   shortName='rbn',
                   longName='ribbon',
                   attributeType='message')
        ribbon_rootGRP.metaParent >> last_follicle.metaParent
        follicle_list.append(last_follicle)
        if i == (segments / 2):
            currentSide = 'C_'
        elif i < (segments / 2):
            currentSide = 'R_'
        else:
            currentSide = 'L_'
        current_name = currentSide + ribbon_rootName
        #currentJointName = currentSide + current_name
        print(current_name)
        current_locator = uf.nest_transform(name=current_name + '_LOC',
                                            action='child',
                                            target=last_follicle.getParent(),
                                            transformObj='locator')
        current_group = uf.nest_transform(name=current_name + '_GRP',
                                          action='parent',
                                          target=current_locator,
                                          transformObj='group')
        pm.addAttr(current_locator,
                   shortName='rbn',
                   longName='ribbon',
                   attributeType='message')
        ribbon_locator_list = ribbon_locator_list + [current_locator]
        ribbon_rootGRP.metaParent >> current_locator.metaParent

    ribbonRef = ribbon_rootGRP

    return ribbonRef
Exemple #38
0
    def create_vfk(self, name = "", numJoints=20.0, numControls=3.0, controlRadius = 4.0, 
                  jointRadius=0.25, jointPrefix = 'joint_', jointGroupPrefix ='vfk_grp_',
                  controlPrefix = 'CTRL_vfk_', controlGroupPrefix = 'OFF_CTRL_vfk_', 
                  boneTranslateAxis = '.tx', boneUpAxis = [0,0,1]):
        
        '''
        if self.close_on_create_chk.checkState() == qc.Qt.Checked:
            self.close
        '''
        
        
        pmc.undoInfo(openChunk=True)
        
        ### Get top and end joints, check for parents/children
        sels = pmc.ls(sl=1)
        topJoint = sels[0]
        endJoint = sels[1]
        
        try:
            print topJoint, ' and ', endJoint, ' selected.'
            ### pmc.listRelatives(topJoint, children=True, type='joint')
        except IndexError:
            print 'Error: Select a joint and an immediate child joint.'
        
            
    
        endChild = pmc.listRelatives(endJoint, c=True)
        if endChild:
            linkJointEnd = pmc.duplicate(endJoint, parentOnly=True, n=endJoint + '_LINK')
            pmc.setAttr(linkJointEnd[0] + '.radius', jointRadius * 2)
            pmc.parent(endChild, linkJointEnd)
            pmc.parent(linkJointEnd, w=True)
            
        topParent = pmc.listRelatives(topJoint, p=True)
        if topParent:
            linkJointTop = pmc.duplicate(topJoint, parentOnly=True,  n=topJoint + '_LINK')
            pmc.setAttr(linkJointTop[0] + '.radius', jointRadius * 2)
            pmc.parent(linkJointTop, topParent)
            pmc.parent(topJoint, linkJointTop)
                
        ### Check basic user-defined values
        if self.name_le.text() != "":
            name = self.name_le.text()
        else:
            name = str(topJoint) + '_'
        if self.joints_le.text() != "":
            numJoints = float(self.joints_le.text())
        if self.controls_le.text() != "":
            numControls = float(self.controls_le.text())
 
        ### Check advanced user-defined values
        if self.control_radius_le.text() != "":
            controlRadius = float(self.control_radius_le.text())
        if self.joint_radius_le.text() != "":
            jointRadius = float(self.joint_radius_le.text())
        if self.joint_prefix_le.text() != "":
            jointPrefix = self.joint_prefix_le.text()
        if self.joint_grp_prefix_le.text() != "":
            jointGroupPrefix = self.joint_grp_prefix_le.text()
        if self.control_prefix_le.text() != "":
            controlPrefix = self.control_prefix_le.text()
        if self.control_grp_prefix_le.text() != "":
            controlGroupPrefix = self.control_grp_prefix_le.text()
        
        if self.bone_trans_axis_radX.isChecked() == True and self.bone_up_axis_radX.isChecked() == True:
            print 'Warning: bone main axis and bone up axis cannot be same.'
            return
        if self.bone_trans_axis_radY.isChecked() == True and self.bone_up_axis_radY.isChecked() == True:
            print 'Warning: bone main axis and bone up axis cannot be same.'
            return
        if self.bone_trans_axis_radZ.isChecked() == True and self.bone_up_axis_radZ.isChecked() == True:
            print 'Warning: bone main axis and bone up axis cannot be same.'
            return                        
        
        if self.bone_trans_axis_radX.isChecked() == True:
            boneTranslateAxis = '.tx'
        if self.bone_trans_axis_radY.isChecked() == True:
            boneTranslateAxis = '.ty'
        if self.bone_trans_axis_radZ.isChecked() == True:
            boneTranslateAxis = '.tz'
        if self.bone_up_axis_radX.isChecked() == True:
            boneUpAxis = [1,0,0]            
        if self.bone_up_axis_radY.isChecked() == True:
            boneUpAxis = [0,1,0]
        if self.bone_up_axis_radZ.isChecked() == True:
            boneUpAxis = [0,0,1]
            
        #### ACTUAL FUNCTION PART
        nurbsWidth = pmc.getAttr(endJoint + boneTranslateAxis)

        self._jointRes(topJoint, endJoint, boneTranslateAxis= boneTranslateAxis, add= numJoints-2)

        surface = pmc.nurbsPlane(pivot=[0,0,0], axis= boneUpAxis, width=nurbsWidth, lengthRatio=0.1, 
                                 u=(numJoints-1), ch=0, n= name + 'vfk_surface')
        
        ## Uncomment to use as polyPlane instead of nurbsSurface
        ## surface = pmc.polyPlane(w=20, h=1, sx=20, sy=1, ax=[0,1,0], cuv=2, ch=0, n= name + 'vfk_surface')
        
        if boneTranslateAxis == '.ty':
            if boneUpAxis == [1,0,0]:
                pmc.setAttr(surface[0] + '.rx', -90)
            if boneUpAxis == [0,0,1]:
                pmc.setAttr(surface[0] + '.rz', -90)
            pmc.makeIdentity(surface[0], apply=True, t=0, r=1, s=0)
        
        if boneTranslateAxis == '.tz':
            if boneUpAxis == [0,1,0]:
                pmc.setAttr(surface[0] + '.ry', -90)
            pmc.makeIdentity(surface[0], apply=True, t=0, r=1, s=0)            

        surface_off = pmc.group(surface, n= name + 'OFF_surface')

        pmc.parent(surface_off, topJoint)
        if boneTranslateAxis == '.tx':
            pmc.xform(surface_off, translation = [nurbsWidth/2, 0, 0], rotation=[0,0,0])
        if boneTranslateAxis == '.ty':
            pmc.xform(surface_off, translation = [0, nurbsWidth/2, 0], rotation=[0,0,0])        
        if boneTranslateAxis == '.tz':
            pmc.xform(surface_off, translation = [0, 0, nurbsWidth/2], rotation=[0,0,0])        
        pmc.parent(surface_off, w=True)

        surface_mtx= pmc.xform(surface, q=True, ws=True, m=True)

        joints = pmc.listRelatives(topJoint, children=1, allDescendents=1)
        joints.append(topJoint)
        joints.reverse()

        for j in xrange(len(joints)):
            pmc.select(joints[j])
            pmc.rename(joints[j], jointPrefix + str(j+1))
                        
            pmc.setAttr(joints[j] + '.radius', jointRadius)
            pmc.addAttr(joints[j], ln='position', min=0, max=1, dv=0, keyable=True)
            pmc.setAttr(joints[j] + '.position', j/(numJoints-1))
            pmc.select(cl=1)

            jmtx = pmc.xform(joints[j], q=True, m=True, ws=True)
            
            if j == 0:
                off_vfk = pmc.group(em=True, n=  name + 'OFF_vfk')
                pmc.xform(off_vfk, ws=True, m=jmtx)
                root = pmc.listRelatives(joints[0], parent=True)      
                for c in xrange(int(numControls)):
                    jparent = pmc.listRelatives(joints[j], parent=True)
                    vfk_grp = pmc.group(em=True, n= name + jointGroupPrefix + 'j' + str(j+1) + '_c' + str(c+1))
                    pmc.xform(vfk_grp, ws=True, m=jmtx)
                    pmc.parent(joints[j], vfk_grp)
                    pmc.parent(vfk_grp, jparent)
                    if c == 0:
                        pmc.parent(vfk_grp, off_vfk)
                if root != None:
                    pmc.parent(off_vfk, root)
            else:
                for c in xrange(int(numControls)):
                    jparent = pmc.listRelatives(joints[j], parent=True)
                    vfk_grp = pmc.group(em=True, n= name + jointGroupPrefix + 'j' + str(j+1) + '_c' + str(c+1))
                    pmc.xform(vfk_grp, ws=True, m=jmtx)
                    pmc.parent(joints[j], vfk_grp)
                    pmc.parent(vfk_grp, jparent)

        ctrlSpacing = (nurbsWidth/(numControls+1))

        for i in xrange(int(numControls)):
            if boneTranslateAxis == '.tx':
                ctrl_normal = [1,0,0]
            if boneTranslateAxis == '.ty':
                ctrl_normal = [0,1,0]
            if boneTranslateAxis == '.tz':
                ctrl_normal = [0,0,1]
            ctrl = pmc.circle(normal=ctrl_normal, sw=360, r=controlRadius, ch=0, n= name + controlPrefix + str(i+1))
            ctrl_off = pmc.group(ctrl, n= name + controlGroupPrefix + str(i+1))
            pmc.xform(ctrl_off, ws=True, m=surface_mtx)
                        
            pmc.parent(ctrl_off, surface)
            pmc.setAttr(ctrl[0] + boneTranslateAxis, ((nurbsWidth/-2) + (ctrlSpacing*(i+1))))
            pmc.parent(ctrl_off, w=True)
            
            flcl = self._parentSurfaceFLCL(ctrl, surface[0])
            
            ctrl_mtx = pmc.xform(ctrl, q=True, m=True, ws=True)
            pmc.xform(ctrl_off, ws=True, m=ctrl_mtx)
            pmc.parent(ctrl_off, flcl[0])
            pmc.parent(ctrl, ctrl_off)
            
            min_falloff = 1/numJoints
            
            pmc.addAttr(ctrl[0], ln='position', min=0, max=10, dv=0, keyable=True)
            pmc.addAttr(ctrl[0], ln='falloff', min=min_falloff, max=1, dv=0.5, keyable=True)
            pmc.addAttr(ctrl[0], ln='numberOfJointsAffected', min=0, max=numJoints, dv=0, keyable=True)
            
            multD = pmc.createNode('multiplyDivide', n= name + 'multD_jAff_vfk_' + str(i+1))
            setR = mc.createNode('setRange', n= name + 'setR_jAff_vfk_' + str(i+1))
                
            pmc.connectAttr(ctrl[0] + '.falloff', multD + '.input1X')
            pmc.setAttr(multD + '.input2X', 2)
            pmc.setAttr(multD + '.operation', 1)
            
            pmc.connectAttr(multD + '.outputX', setR + '.valueX')
            pmc.setAttr(setR + '.oldMinX', 0)
            pmc.setAttr(setR + '.oldMaxX', 1)
            pmc.setAttr(setR + '.minX', 0)
            pmc.setAttr(setR + '.maxX', numJoints)
            pmc.connectAttr(setR + '.outValueX', ctrl[0] + '.numberOfJointsAffected')

               
            paramU = pmc.getAttr(flcl[0] + '.parameterU')
            
            div_ten = pmc.createNode('multiplyDivide', n="DIV_" + name + controlPrefix + str(i+1))
            pmc.setAttr(div_ten.input2X, 10)
            pmc.setAttr(div_ten.operation, 2)

            pmc.connectAttr(ctrl[0] + '.position', div_ten.input1X)

            pmc.connectAttr(div_ten.outputX, flcl[0] + '.parameterU')

            pmc.setAttr(ctrl[0] + '.position', paramU * 10.0)
            
            fPos_plus = pmc.createNode('plusMinusAverage', n= name + 'fPosPlus_vfk_' + str(i+1))
            pmc.connectAttr(div_ten.outputX, fPos_plus + '.input1D[0]', f=True)
            pmc.connectAttr(ctrl[0] + '.falloff', fPos_plus + '.input1D[1]', f=True)
            pmc.setAttr(fPos_plus + '.operation', 1)
            
            fPos_minus = pmc.createNode('plusMinusAverage', n=  name + 'fPosMinus_vfk_' + str(i+1))
            pmc.connectAttr(div_ten.outputX, fPos_minus + '.input1D[0]', f=True)
            pmc.connectAttr(ctrl[0] + '.falloff', fPos_minus + '.input1D[1]', f=True)
            pmc.setAttr(fPos_minus + '.operation', 2)
            
            for f in (fPos_plus, fPos_minus):
                for j in xrange(len(joints)):
                    upperM = pmc.createNode('plusMinusAverage', n= (name + f + '_upperM_j' + str(j+1) + '_c' + str(i+1)))
                    lowerM = pmc.createNode('plusMinusAverage', n= (name + f + '_lowerM_j' + str(j+1) + '_c' + str(i+1)))
                    
                    pmc.setAttr(upperM + '.operation', 2)
                    pmc.setAttr(lowerM + '.operation', 2)
                    
                    pmc.connectAttr(joints[j] + '.position', upperM + '.input1D[0]')
                    pmc.connectAttr(f + '.output1D', upperM + '.input1D[1]')
                    
                    pmc.connectAttr(div_ten.outputX, lowerM + '.input1D[0]')
                    pmc.connectAttr(f + '.output1D', lowerM + '.input1D[1]')
                    
                    divA = pmc.createNode('multiplyDivide', n= f + '_divA_j' + str(j+1) + '_c' + str(i+1))
                    pmc.setAttr(divA + '.operation', 2)
                    pmc.connectAttr(upperM + '.output1D', divA + '.input1X')
                    pmc.connectAttr(lowerM + '.output1D', divA + '.input2X')
                    
                    multA = pmc.createNode('multiplyDivide', n= f + '_multA_j' + str(j+1) + '_c' + str(i+1))
                    pmc.setAttr(multA + '.operation', 1)
                    pmc.connectAttr(divA + '.outputX', multA + '.input1X')
                    pmc.setAttr(multA + '.input2X', 2)

                    divB = pmc.createNode('multiplyDivide', n= f + '_divB_j' + str(j+1) + '_c' + str(i+1))
                    pmc.setAttr(divB + '.operation', 2)
                    pmc.connectAttr(multA + '.outputX', divB + '.input1X')
                    pmc.connectAttr(ctrl[0] + '.numberOfJointsAffected', divB + '.input2X')
                    
                    
            for j in xrange(len(joints)):
                cond = pmc.createNode('condition', n= name + 'cond_j' + str(j+1) + '_c' + str(i+1))
                pmc.setAttr(cond + '.operation', 3)
                pmc.connectAttr(div_ten.outputX, cond + '.firstTerm') # then use minus
                pmc.connectAttr(joints[j] + '.position', cond + '.secondTerm') # then use plus

                pmc.connectAttr(fPos_minus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfTrueR')
                pmc.connectAttr(fPos_minus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfTrueG')
                pmc.connectAttr(fPos_minus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfTrueB')

                pmc.connectAttr(fPos_plus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfFalseR')
                pmc.connectAttr(fPos_plus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfFalseG')
                pmc.connectAttr(fPos_plus + '_divB_j' + str(j+1) + '_c' + str(i+1) + '.outputX', cond + '.colorIfFalseB')
                
                cond_neg = pmc.createNode('condition', n= name + 'cond_neg_j' + str(j+1) + '_c' + str(i+1))
                pmc.connectAttr(cond + '.outColorR', cond_neg + '.firstTerm')
                pmc.setAttr(cond_neg + '.secondTerm', 0)
                pmc.setAttr(cond_neg + '.operation', 2)
                pmc.connectAttr(cond + '.outColor', cond_neg + '.colorIfTrue')
                pmc.setAttr(cond_neg + '.colorIfFalse', [0,0,0])
                
                multiFinalRot = pmc.createNode('multiplyDivide', n=  name + 'multiFinalRot_j' + str(j+1) + '_c' + str(i+1))
                pmc.setAttr(multiFinalRot + '.operation', 1)
                pmc.connectAttr(cond_neg + '.outColor', multiFinalRot + '.input1')
                pmc.connectAttr(ctrl[0] + '.rotate', multiFinalRot + '.input2')
                
                pmc.connectAttr(multiFinalRot + '.output', name + jointGroupPrefix + 'j' + str(j+1) + '_c' + str(i+1) + '.rotate')

                '''
                multiFinalScl = pmc.createNode('multiplyDivide', n=  name + 'multiFinalScl_j' + str(j+1) + '_c' + str(i+1))
                pmc.setAttr(multiFinalScl + '.operation', 1)
                pmc.connectAttr(cond + '.outColor', multiFinalScl + '.input1')
                pmc.connectAttr(ctrl[0] + '.scale', multiFinalScl + '.input2')
                
                pmc.connectAttr(multiFinalScl + '.output', name + jointGroupPrefix + 'j' + str(j+1) + '_c' + str(i+1) + '.scale')
                '''
            self._ctrlDBL(ctrl)
        
        if endChild:
            pmc.parent(linkJointEnd, endJoint)
 
        pmc.undoInfo(closeChunk=True)
        pmc.undoInfo(openChunk=True)
            
        pmc.skinCluster(joints, name + 'vfk_surface', mi=1)
        
        pmc.undoInfo(closeChunk=True)
Exemple #39
0
    def bdBuildRbnDT(self,name,start,end,segments):
        surfaceRbn = pm.nurbsPlane(ax = [0,0,22], d=3, u=1, v=segments , w=1, lr = segments)[0]
        surfaceRbn.rename(name)
        flcGrp = self.bdCreateFol(surfaceRbn,segments)

        surfaceRbn_BS = surfaceRbn.duplicate()[0]
        surfaceRbn_BS.rename(name + '_BS')
        surfaceRbn_BS.translateX.set(segments * 0.5 )
        blendshapeNode = pm.blendShape(surfaceRbn_BS,surfaceRbn,name=surfaceRbn.name() + '_blendShape')[0]
        blendshapeNode.attr(surfaceRbn_BS.name()).set(1)

        locatorsRbn = []

        topLocator = pm.spaceLocator()
        topLocator.rename(name + '_loc_top_CON')
        topLocator.translateY.set(segments * 0.5)
        pm.makeIdentity(topLocator,apply=True,t=True,r=True,s=True)

        midLocator = pm.spaceLocator()
        midLocator.rename(name + '_loc_mid_CON')
        midLocatorGrp = pm.group(midLocator,name=midLocator.name() + '_grp')
        pm.makeIdentity(midLocator,apply=True,t=True,r=True,s=True)

        botLocator = pm.spaceLocator()
        botLocator.rename(name + '_loc_bot_CON')
        botLocator.translateY.set(segments * -0.5)
        pm.makeIdentity(botLocator,apply=True,t=True,r=True,s=True)

        locatorsRbn.append(topLocator)
        locatorsRbn.append(midLocator)
        locatorsRbn.append(botLocator)

        pm.pointConstraint(topLocator,botLocator,midLocatorGrp)
        conGrp = pm.group([topLocator,midLocatorGrp,botLocator],n=name.replace('srf','CON_GRP'))


        curveDrv = pm.curve(d=2, p=[(0, segments * 0.5, 0), (0, 0, 0), (0, segments * -0.5, 0)],k=[0,0,1,1])
        curveDrv.rename(name.replace('srf', 'wire_CRV'))
        curveDrv.translateX.set(segments * 0.5)

        wireDef = pm.wire(surfaceRbn_BS,w=curveDrv,en=1,gw=False,ce=0, li=0, dds = [0,20], n=name.replace('srf','wire'))

        #kind of a hack
        wireDefBase = wireDef[0].baseWire[0].listConnections(d=False,s=True)
        curveCLS,clsGrp = self.bdClustersOnCurve(curveDrv,segments)

        for i in range(3):
            locatorsRbn[i].translate.connect(curveCLS[i].translate)

        #organize a bit
        moveGrp = pm.group([conGrp,surfaceRbn],name=name.replace('srf','move_GRP'))
        extraGrp = pm.group([flcGrp,surfaceRbn_BS,clsGrp,curveDrv,wireDefBase],name = name.replace('srf','extra_GRP'))
        allGrp = pm.group([moveGrp,extraGrp],name = name.replace('srf','RBN'))

        self.bdFlcScaleCnstr(moveGrp,flcGrp)

        globalCon = pm.spaceLocator()
        globalCon.rename(name.replace("srf",'world_CON'))

        pm.parent(globalCon,allGrp)
        pm.parent(moveGrp,globalCon)

        self.bdCreateJoints(flcGrp)

        twistDef, twistDefTransform = self.bdAddTwist(surfaceRbn_BS)
        pm.parent(twistDefTransform, extraGrp)
        topLocator.rotateY.connect(twistDef.startAngle)
        botLocator.rotateY.connect(twistDef.endAngle)

        pm.reorderDeformers(wireDef[0],twistDef,surfaceRbn_BS)
Exemple #40
0
def CreateSurface(pos1, pos2, Div=10):

    try:
        pm.select(pos1)
        tempPos = pm.cluster(n='Temp')[1]
        JntPos1 = pm.createNode('joint', n=(pos1 + '_Pos1Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos1))
        pm.makeIdentity(JntPos1, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    except:
        tempPos = pm.createNode('transform', n='Temp')
        pm.delete(pm.parentConstraint(pos1, tempPos))
        JntPos1 = pm.createNode('joint', n=(pos1 + '_Pos1Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos1))
        pm.makeIdentity(JntPos1, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    try:
        pm.select(pos2)
        tempPos = pm.cluster(n='Temp')[1]
        JntPos2 = pm.createNode('joint', n=(pos2 + '_Pos2Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos2))
        pm.makeIdentity(JntPos2, a=1, t=1, r=1, s=1)

        pm.delete(tempPos)

    except:
        tempPos = pm.createNode('transform', n='Temp')
        pm.delete(pm.parentConstraint(pos2, tempPos))
        JntPos2 = pm.createNode('joint', n=(pos2 + '_Pos2Jnt'))
        pm.delete(pm.parentConstraint(tempPos, JntPos2))
        pm.makeIdentity(JntPos2, a=1, t=1, r=1, s=1)
        pm.delete(tempPos)

    pm.parent(JntPos2, JntPos1)

    pm.joint(JntPos1, e=1, oj='xyz', secondaryAxisOrient='yup')
    pm.joint(JntPos2, e=1, oj='none', ch=1, zso=1)

    distanceND = pm.createNode('distanceBetween')

    JntPos1.worldMatrix[0] >> distanceND.inMatrix1
    JntPos2.worldMatrix[0] >> distanceND.inMatrix2
    Dist = distanceND.distance.get()

    surface = pm.nurbsPlane(w=Dist, lr=.01, u=Div, ax=(0, 1, 0), ch=0)
    print surface
    bsSurface = pm.duplicate(surface)

    pm.delete(pm.parentConstraint(JntPos1, JntPos2, surface[0]))
    pm.delete(JntPos1, JntPos2)
    fols = []
    for i in range(0, Div):
        val = ((.5 / float(Div)) * (i + 1) * 2) - ((.5 / float(Div * 2)) * 2)

        fol = pm.createNode('transform', n=('Tst_' + str(i)), ss=1)
        folShape = pm.createNode('follicle',
                                 n=fol.name() + 'Shape',
                                 p=fol,
                                 ss=1)
        geo = surface[0]
        geo.local >> folShape.inputSurface
        geo.worldMatrix[0] >> folShape.inputWorldMatrix
        folShape.outRotate >> fol.rotate
        folShape.outTranslate >> fol.translate
        fol.inheritsTransform.set(False)
        folShape.parameterV.set(0.5)
        folShape.parameterU.set(val)
        fols.append(fol)
    SknJnts = []
    for i in range(0, Div):
        val = ((.5 / float(Div)) * (i + 1) * 2) - ((.5 / float(Div * 2)) * 2)

        fol = pm.createNode('transform', n=('Tst_' + str(i)), ss=1)
        folShape = pm.createNode('follicle',
                                 n=fol.name() + 'Shape',
                                 p=fol,
                                 ss=1)
        geo = bsSurface
        geo.local >> folShape.inputSurface
        geo.worldMatrix[0] >> folShape.inputWorldMatrix
        folShape.outRotate >> fol.rotate
        folShape.outTranslate >> fol.translate
        fol.inheritsTransform.set(False)
        folShape.parameterV.set(0.5)
        folShape.parameterU.set(val)
        jnt = pm.joint(n='FollicleJnt' + i)
        pm.delete(pm.parentConstraint(fol, jnt))
    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)
Exemple #42
0
    def doRig(self):
        anchorList = []
        cntrlList = []
        locList = []
        offCtrlLoc=[]
        offAuxLoc = []

        dummyCrv = self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv'
        pm.hide(pm.polyCube(n=dummyCrv))

        if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']):
            pm.delete(self.ribbonDict['moveallSetup']['nameTempl'])
        if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']):
            pm.delete(self.ribbonDict['noMoveSetup']['nameTempl'])

        ###Estrutura que nao deve ter transformacao
        noMoveSpace = pm.group(empty=True, n=self.ribbonDict['noMoveSetup']['nameTempl'])

        if not pm.objExists('NOMOVE'):
            pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE')
        else:
            pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE')

        pm.parent(self.ribbonDict['moveallSetup']['nameTempl']+'_dummy_crv', noMoveSpace)

        noMoveSpace.visibility.set(0)
        noMoveSpace.translate.set(self.size * -0.5, 0, 0)

        noMoveBend1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
        noMoveBend2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)

        noMoveCrvJnt = pm.curve(bezier=True, d=3,
                                p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0), (self.size * -0.496, 0, 0),
                                   (self.size * -0.495, 0, 0), (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0),
                                   (0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0),
                                   (self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0), (self.size * 0.499, 0, 0),
                                   (self.size * 0.50, 0, 0)],
                                k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10])
        noMoveCrvTweak1 = pm.curve(d=2,
                                   p=[(self.size * -0.5, 0, 0), (self.size * -0.25, 0, 0), (self.size * 0, 0, 0)],
                                   k=[0, 0, 1, 1])
        noMoveCrvTweak2 = pm.curve(d=2,
                                   p=[(self.size * 0.0, 0, 0), (self.size * 0.25, 0, 0), (self.size * 0.50, 0, 0)],
                                   k=[0, 0, 1, 1])

        # Deformers das superficies noMove
        twist1 = pm.nonLinear(noMoveBend1[0], type='twist')  # twist das superficies noMove
        twist2 = pm.nonLinear(noMoveBend2[0], type='twist')
        twist1[1].rotateZ.set(90)
        twist2[1].rotateZ.set(90)

        wireTweak1 = pm.wire(noMoveBend1[0], w=noMoveCrvTweak1, dds=[(0, 50)])
        wireTweak2 = pm.wire(noMoveBend2[0], w=noMoveCrvTweak2, dds=[(0, 50)])

        wireDef = pm.wire(noMoveBend1[0], noMoveBend2[0], w=noMoveCrvJnt, dds=[(0, 50)])  # Wire das superficies noMove
        wireDef[0].rotation.set(1)  # seta wire controlando rotacao
        baseWire = [x for x in wireDef[0].connections() if 'BaseWire' in x.name()]
        baseWireTweak1 = [x for x in wireTweak1[0].connections() if 'BaseWire' in x.name()]
        baseWireTweak2 = [x for x in wireTweak2[0].connections() if 'BaseWire' in x.name()]

        pm.group(baseWire, baseWireTweak1, baseWireTweak2, noMoveCrvJnt, noMoveCrvTweak1, noMoveCrvTweak2,
                 noMoveBend1[0], noMoveBend2[0], p=noMoveSpace, n=self.name + 'Deforms')
        pm.parent(twist1[1], twist2[1], noMoveSpace)

        ###Estrutura que pode ser movida
        cntrlsSpace = pm.group(empty=True, n=self.ribbonDict['moveallSetup']['nameTempl'])
        cntrlsSpace.translate.set(self.size * -0.5, 0, 0)
        bendSurf1 = pm.nurbsPlane(p=(self.size * -0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)
        bendSurf2 = pm.nurbsPlane(p=(self.size * 0.25, 0, 0), ax=(0, 0, 1), w=self.size * 0.5, lr=.1, d=3, u=5, v=1)

        # blendShape transferindo as deformaacoes para a superficie move
        blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0])
        blend2 = pm.blendShape(noMoveBend2[0], bendSurf2[0])
        pm.blendShape(blend1, e=True, w=[(0, 1)])
        pm.blendShape(blend2, e=True, w=[(0, 1)])
        pm.parent(bendSurf1[0], bendSurf2[0], cntrlsSpace)

        ##Cntrls
        tweak1Cls = pm.cluster(noMoveCrvTweak1.name()+'.cv[1]')
        tweak2Cls = pm.cluster(noMoveCrvTweak2.name() + '.cv[1]')

        displaySetup = self.ribbonDict['ctrlTweakSetup'].copy()

        cntrlName = displaySetup['nameTempl'] + '1'
        cntrlTweak1 = controlTools.cntrlCrv(name=cntrlName, obj=tweak1Cls[1], connType='connection',
                                            align='pivot', offsets=1, **displaySetup)

        cntrlName = displaySetup['nameTempl'] + '2'
        cntrlTweak2 = controlTools.cntrlCrv(name=cntrlName, obj=tweak2Cls[1], connType='connection',
                                            align='pivot', offsets=1, **displaySetup)

        controlTools.addMultiply([cntrlTweak1.getParent(), cntrlTweak2.getParent()])

        tweakFoll1 = self.attachObj(obj=cntrlTweak1.getParent(3), mesh=bendSurf1[0], u=0.5, v=0.5, mode=4)
        tweakFoll2 = self.attachObj(obj=cntrlTweak2.getParent(3), mesh=bendSurf2[0], u=0.5, v=0.5, mode=4)
        tweakGrp = pm.group(tweak1Cls[1], tweak2Cls[1], n=self.name+'TweakCls_grp')
        pm.parent(tweakGrp, noMoveSpace)
        pm.parent(cntrlTweak1.getParent(3), cntrlTweak2.getParent(3), cntrlsSpace)

        for i in range(0, 7):
            anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) + ']')
            pm.cluster(anchor[1], e=True, g=dummyCrv)
            clsHandle = anchor[1]
            anchorGrp = pm.group(em=True, n=self.name+'clusterGrp' + str(i))
            anchorDrn = pm.group(em=True, n=self.name+'clusterDrn' + str(i), p=anchorGrp)
            pos = pm.xform(anchor[1], q=True, ws=True, rp=True)
            pm.xform(anchorGrp, t=pos, ws=True)
            pm.parent(anchor[1], anchorDrn)
            anchorList.append(anchor[1])
            if i == 0 or i == 6:
                displaySetup = self.ribbonDict['cntrlSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)
            elif i == 3:
                displaySetup = self.ribbonDict['midCntrlSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)
            else:
                displaySetup = self.ribbonDict['cntrlTangSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName, obj=anchor[1], **displaySetup)

            offCtrlLoc.append(pm.spaceLocator(n=cntrlName+'off_loc'))
            offCtrlLoc[-1].localScale.set(0.2, 0.2, 0.2)
            pm.parent(offCtrlLoc[-1], cntrl, r=True)
            if i in [1, 2, 4, 5]:
                offCtrlLoc[-1].getShape().visibility.set(False)

            # Nao pode fazer conexao na criacao do controle, pois tera conexao direta
            pm.xform(cntrl.getParent(), t=pos, ws=True)
            # estrutura de buffers para conexao direta
            auxLocGrp = pm.group(em=True, n=self.name + 'Aux_grp')
            auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + str(i)+ 'Aux_loc')
            pm.xform(auxLocGrp, t=pos, ws=True)
            loc = pm.PyNode(auxLoc)

            if i==0 or i==3 or i==6:
                tmpOffAuxLoc = pm.group(em=True, n=self.name + str(i) + 'AuxOff_loc')
                offAuxLoc.append(tmpOffAuxLoc)
                pm.parent(tmpOffAuxLoc, auxLoc, r=True)
                offCtrlLoc[-1].translate >> offAuxLoc[-1].translate
                offCtrlLoc[-1].rotate >> offAuxLoc[-1].rotate

            if i == 1 or i == 4:
                pm.xform(anchorGrp, s=(-1, 1, 1), r=True)
                pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True)
                pm.xform(loc.getParent(), s=(-1, 1, 1), r=True)

            # Conexoes dos buffers cm os clusters e com os controles
            pm.parentConstraint(cntrl, loc, mo=True)
            loc.translate >> anchorDrn.translate
            loc.rotate >> anchorDrn.rotate
            cntrlList.append(cntrl)
            locList.append(loc)

        # workaround do flip do inicio do wire(adicao de mais pontos)
        startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]')
        endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]')
        pm.cluster(startCls[1], e=True, g=dummyCrv)
        pm.cluster(endCls[1], e=True, g=dummyCrv)

        pm.parent(startCls[1], anchorList[0])
        pm.parent(endCls[1], anchorList[6])

        cntrlsSpace.addAttr('midCtrlViz', at='double', dv=1, max=1, min=0, k=True, h=False)
        cntrlsSpace.addAttr('bezierCtrlViz', at='double', dv=1,max=1, min=0, k=True, h=False)
        cntrlsSpace.addAttr('bendExtraCtrlViz', at='double',max=1, min=0, dv=1, k=True, h=False)
        cntrlsSpace.addAttr('extraCtrlsVis', at='double', dv=0,max=1, min=0, k=True, h=False)
        cntrlList[0].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True)
        cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True)
        cntrlList[3].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True)
        cntrlList[6].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True)
        cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True)

        cntrlList[0].twist >> twist1[0].endAngle
        cntrlList[3].twist >> twist1[0].startAngle
        cntrlList[3].twist >> twist2[0].endAngle
        cntrlList[6].twist >> twist2[0].startAngle

        # cria sistema do tweak pra compensar twist da ribbon
        tweak1Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
        tweak1Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
        tweak1Add = pm.createNode('addDoubleLinear', name='tweak1Add')

        tweak2Twist1Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
        tweak2Twist2Multi = pm.createNode('multDoubleLinear', name='tweak1Twist1Multi')
        tweak2Add = pm.createNode('addDoubleLinear', name='tweak1Add')

        cntrlList[0].twist >> tweak1Twist1Multi.input1
        tweak1Twist1Multi.input2.set(-0.5)
        cntrlList[3].twist >> tweak1Twist2Multi.input1
        tweak1Twist2Multi.input2.set (-0.5)
        tweak1Twist1Multi.output >> tweak1Add.input1
        tweak1Twist2Multi.output >> tweak1Add.input2
        tweak1Add.output >> cntrlTweak1.getParent(2).rotate.rotateX

        cntrlList[6].twist >> tweak2Twist1Multi.input1
        tweak2Twist1Multi.input2.set(-0.5)
        cntrlList[3].twist >> tweak2Twist2Multi.input1
        tweak2Twist2Multi.input2.set(-0.5)
        tweak2Twist1Multi.output >> tweak2Add.input1
        tweak2Twist2Multi.output >> tweak2Add.input2
        tweak2Add.output >> cntrlTweak2.getParent(2).rotate.rotateX

        # hierarquia
        pm.parent(anchorList[1].getParent(2), anchorList[0])
        pm.parent(anchorList[5].getParent(2), anchorList[6])
        pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2), anchorList[3])
        pm.parent(cntrlList[1].getParent(), offCtrlLoc[0])
        pm.parent(cntrlList[5].getParent(), offCtrlLoc[6])
        pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(), offCtrlLoc[3])
        pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(), cntrlList[6].getParent(), cntrlsSpace)
        pm.parent(locList[1].getParent(), offAuxLoc[0])
        pm.parent(locList[5].getParent(), offAuxLoc[2])
        pm.parent(locList[2].getParent(), locList[4].getParent(), offAuxLoc[1])
        pm.parent(locList[3].getParent(), locList[0].getParent(), locList[6].getParent(), cntrlsSpace)
        pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2), anchorList[6].getParent(2), noMoveSpace)

        for i, j in zip([1, 2, 4, 5], [0, 3, 3, 6]):
            crv = pm.curve(d=1, p=[(1, 0, 0), (-1, 0, 0)], k=[0, 1])
            crv.inheritsTransform.set(False)
            crv.template.set(True)
            offCtrlLoc[i].worldPosition[0] >> crv.getShape().controlPoints[0]
            offCtrlLoc[j].worldPosition[0] >> crv.getShape().controlPoints[1]

            pm.parent(crv, offCtrlLoc[i], r=True)

        # Skin joints do ribbon
        skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts')
        follGrp = pm.group(em=True, n=self.name + 'Foll_grp')
        pm.parent(tweakFoll1, tweakFoll2, follGrp)

        # cria ramps para controlar o perfil de squash e stretch
        ramp1 = pm.createNode('ramp', n=self.name+'SquashRamp1')
        ramp1.attr('type').set(1)

        ramp2 = pm.createNode('ramp', n=self.name+'SquashRamp2')
        ramp2.attr('type').set(1)

        expre1 = "float $dummy = " + ramp1.name() + ".outAlpha;float $output[];float $color[];"
        expre2 = "float $dummy = " + ramp2.name() + ".outAlpha;float $output[];float $color[];"

        extraCntrlsGrp = pm.group(em=True, r=True, p=cntrlsSpace, n=self.name + 'ExtraCntrls')

        # loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon.
        # cria tmb node tree pro squash/stretch
        # e controles extras
        vIncrement = float((1.0 - (self.offsetStart + self.offsetEnd)) / ((self.numJnts - 2) / 2.0))

        for i in range(1, (self.numJnts / 2) + 1):
            # cria estrutura pra superficie 1
            pm.select(cl=True)
            jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'A' + str(i) + self.jntSulfix

            jnt1 = pm.joint(p=(0, 0, 0), n=jntName)
            self.skinJoints.append(jnt1)
            displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
            cntrlName = displaySetup['nameTempl'] + 'A' + str(i)
            cntrl1 = controlTools.cntrlCrv(name=cntrlName, obj=jnt1, connType='constraint', **displaySetup)

            # node tree
            blend1A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1A')
            blend1B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend1B')
            gammaCorr1 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma1')
            cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX
            cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX
            blend1A.input[0].set(1)
            gammaCorr1.outValueX >> blend1A.input[1]
            blend1B.input[0].set(1)
            blend1A.output >> blend1B.input[1]
            cntrlList[3].attr ('autoVolume') >> blend1B.attributesBlender
            blend1B.output >> cntrl1.getParent().scaleY
            blend1B.output >> cntrl1.getParent().scaleZ
            # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch
            expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str(
                self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name() + " `;$output[" + str(
                i) + "] = $color[0];" + blend1A.name() + ".attributesBlender=$output[" + str(i) + "];"

            # cria estrutura pra superficie 2
            pm.select(cl=True)

            jntName = self.ribbonDict['jntSetup']['nameTempl'] + 'B' + str(i) + self.jntSulfix
            jnt2 = pm.joint(p=(0, 0, 0), n=jntName)
            self.skinJoints.append(jnt2)
            displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
            cntrlName = displaySetup['nameTempl'] + 'B' + str(i)
            cntrl2 = controlTools.cntrlCrv(name=cntrlName, connType='constraint', obj=jnt2, **displaySetup)

            # node tree
            blend2A = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2A')
            blend2B = pm.createNode('blendTwoAttr', n=self.name+'VolumeBlend2B')
            gammaCorr2 = pm.createNode('gammaCorrect', n=self.name+'VolumeGamma2')
            cntrlList[6].attr('autoVolumStregth') >> gammaCorr2.gammaX
            cntrlList[6].attr('stretchDist') >> gammaCorr2.value.valueX
            blend2A.input[0].set(1)
            gammaCorr2.outValueX >> blend2A.input[1]
            blend2B.input[0].set(1)
            blend2A.output >> blend2B.input[1]
            cntrlList[3].attr('autoVolume') >> blend2B.attributesBlender
            blend2B.output >> cntrl2.getParent().scaleY
            blend2B.output >> cntrl2.getParent().scaleZ
            # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch

            expre2 = expre2 + "$color = `colorAtPoint -o RGB -u " + str(
                self.offsetStart + (i - 1) * vIncrement) + " -v 0.5 " + ramp2.name() + " `;$output[" + str(
                i) + "] = $color[0];" + blend2A.name() + ".attributesBlender=$output[" + str(i) + "];"

            # prende joints nas supeficies com follicules
            foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4)
            foll2 = self.attachObj(cntrl2.getParent(), bendSurf2[0], self.offsetStart + (i - 1) * vIncrement, 0.5, 4)

            pm.parent(cntrl1.getParent(), cntrl2.getParent(), extraCntrlsGrp)
            pm.parent(jnt1, jnt2, skinJntsGrp)
            pm.parent(foll1, foll2, follGrp)

        pm.select (cl=True)
        jntName = self.ribbonDict['jntSetup']['nameTempl'] +'Elbow' + self.jntSulfix
        elbowJnt = pm.joint(p=(0, 0, 0), n=jntName)
        pm.parent(elbowJnt, skinJntsGrp)

        elbowAuxFoll1 = self.createFoll(bendSurf1[0], 0.999, 0.5)
        elbowAuxFoll2 = self.createFoll(bendSurf2[0], 0.001, 0.5)
        pm.parent(elbowAuxFoll1, elbowAuxFoll2, follGrp)
        orientConstraint = pm.PyNode(pm.orientConstraint(elbowAuxFoll1, elbowAuxFoll2, elbowJnt, mo=False))
        orientConstraint.interpType.set(2)
        pm.pointConstraint(cntrlList[3], elbowJnt, mo=False)

        # seta expressoes para so serem avaliadas por demanda
        pm.expression(s=expre1, ae=False, n=self.name+'Expression1')
        pm.expression(s=expre2, ae=False, n=self.name+'Expression2')

        pm.parent(skinJntsGrp, cntrlsSpace)
        pm.parent(follGrp, noMoveSpace)

        # hideCntrls
        pm.toggle(bendSurf1[0], bendSurf2[0], g=True)
        bendSurf1[0].visibility.set(0)
        bendSurf2[0].visibility.set (0)
        # skinJntsGrp.visibility.set(0)
        cntrlsSpace.extraCtrlsVis >> extraCntrlsGrp.visibility
        cntrlsSpace.bezierCtrlViz >> cntrlList[0].getParent().visibility
        cntrlsSpace.midCtrlViz >> cntrlList[3].getParent().visibility
        cntrlsSpace.bezierCtrlViz >> cntrlList[4].getParent().visibility
        cntrlsSpace.bezierCtrlViz >> cntrlList[2].getParent().visibility
        cntrlsSpace.bezierCtrlViz >> cntrlList[6].getParent().visibility
        cntrlsSpace.bendExtraCtrlViz >> cntrlTweak1.getParent().visibility
        cntrlsSpace.bendExtraCtrlViz >> cntrlTweak2.getParent().visibility

        # povoa ribbon Dict
        self.ribbonDict['name'] = 'bezierRibbon'
        self.ribbonDict['ribbonMoveAll'] = cntrlsSpace
        for i in range(0, 7):
            self.ribbonDict['cntrl' + str(i)] = cntrlList[i]
Exemple #43
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()
def addOffset(node):
    '''
    - add a grp above node
    - add a nurbs plane under grp's parent (get the same local space)
    - unparent nurbs plane to world space (or whichever deformer space - e.g. headLattice)
    - add pointOnSurfaceInfo to get position and orientation for grp
    - use aimconstraint to convert vectors to orientation
    - return grp as offset
    
    example use for mathilda:
    import rigger.modules.surfOffset as surfOffset
    reload(surfOffset)
    nodes = pm.ls(sl=True)
    offsets = []
    for n in nodes:
        offsetGrp = surfOffset.addOffset(n)
        offsets.append(offsetGrp[1])
    pm.select(offsets)
    '''
    nodeMatrix = node.getMatrix(worldSpace=True)
    offsetGrp = pm.group(em=True, n=node+'_surfOffset_grp')
    offsetGrp.setMatrix(nodeMatrix, worldSpace=True)
    
    # hierarchy
    # also check for sibling nodes, such as scaleX/Y xfos
    siblings = node.getSiblings()
    for sibling in siblings:
        offsetGrp | sibling
    parentNode = node.getParent()
    parentNode | offsetGrp | node
    
    # nurbs plane
    plane = pm.nurbsPlane(n=node+'_surfOffset_srf', ch=False, 
                          degree=1, axis=(0,1,0))[0]
    # parentNode | plane # don't
    # use separate hierachy
    planeGrp = pm.group(plane, n=node+'_surfOffsetSrf_grp')
    planeHm = pm.group(planeGrp, n=node+'_surfOffsetSrf_hm')
    planeHm.setMatrix(nodeMatrix, worldSpace=True)
    parentNode | planeHm
    
    # point on surface info
    posi = pm.createNode('pointOnSurfaceInfo', n=node+'_surfOffset_posi')
    plane.local >> posi.inputSurface
    posi.parameterU.set(0.5)
    posi.parameterV.set(0.5)
    '''
    # convert vectors to orientation using aim constraint
    aimc = pm.createNode('aimConstraint', n=node+'_surfOffset_aimc')
    offsetGrp | aimc
    posi.normal >> aimc.tg[0].tt
    posi.tangentU >> aimc.worldUpVector
    aimc.aimVector.set((0,1,0))
    aimc.upVector.set((1,0,0))
    '''
    '''
    # use cross products instead of aim constraint
    vpZ = pm.createNode('vectorProduct', n=node+'_surfOffsetZVec_vp')
    posi.normal >> vpZ.input1 # Y
    posi.tangentU >> vpZ.input2
    vpZ.operation.set(2)
    vpX = pm.createNode('vectorProduct', n=node+'_surfOffsetXVec_vp')
    posi.normal >> vpZ.input1 # Y
    posi.tangentU >> vpZ.input2
    vpZ.operation.set(2)'''
    
    # just use vectors from posi to construct matrix!
    mat = pm.createNode('fourByFourMatrix', n=node+'_surfOffset_fbfm')
    # x-vector
    posi.tangentUx >> mat.in00
    posi.tangentUy >> mat.in01
    posi.tangentUz >> mat.in02
    # y-vector
    posi.normalX >> mat.in10
    posi.normalY >> mat.in11
    posi.normalZ >> mat.in12
    # z-vector
    posi.tangentVx >> mat.in20
    posi.tangentVy >> mat.in21
    posi.tangentVz >> mat.in22
    # position
    posi.positionX >> mat.in30
    posi.positionY >> mat.in31
    posi.positionZ >> mat.in32

    # drive grp
    dcm = pm.createNode('decomposeMatrix', n=node+'_surfOffset_dcm')
    mat.output >> dcm.inputMatrix
    dcm.outputTranslate >> offsetGrp.t
    dcm.outputRotate >> offsetGrp.r
    
    return offsetGrp, plane
Exemple #45
0
def create_nurbs_plane_from_joints(jnts, degree=1, width=1):
    """
    Create a nurbsPlane following a provided joint chain.
    Note that the plane is oriented in the up axis (Y) of each joint.
    """

    # Create nurbsPlane
    num_patches_u = (len(jnts)-1)
    plane = pymel.nurbsPlane(d=degree, u=num_patches_u)[0]

    pos_upp_local = pymel.datatypes.Point(0,0,width)
    pos_dwn_local = pymel.datatypes.Point(0,0,-width)

    # Define how much in-between we need to compute.
    num_patches_v = 2
    num_inbetweens_outside = 0
    num_inbetweens_inside = 0
    add_inside_edges = True
    if degree == 1:  # Linear
        pass
    elif degree == 2:  # Quadratic
        num_inbetweens_outside = 1
        num_inbetweens_inside = 1
        add_inside_edges = False
        num_patches_v = 3
    elif degree == 3:  # Cubic
        num_inbetweens_outside = 1
        num_patches_v = 4
    else:
        # TODO: Support missing degrees!
        Exception("Unexpected value for parameter degree, got {0}.".format(degree))

    # Resolve ratios to compute v positions more easily.
    v_ratios = [v / float(num_patches_v-1) for v in range(num_patches_v)]

    # Resolve positions for edges
    edges_positions_upp = []
    edges_positions_dwn = []
    for i, jnt in enumerate(jnts):
        jnt_tm_world = jnt.getMatrix(worldSpace=True)
        pos_upp = pos_upp_local * jnt_tm_world
        pos_dwn = pos_dwn_local * jnt_tm_world
        edges_positions_upp.append(pos_upp)
        edges_positions_dwn.append(pos_dwn)

    # Resolve all positions including in-between
    all_positions = []

    num_edges = len(edges_positions_upp)
    for i in range(num_edges-1):
        pos_upp_inn = edges_positions_upp[i]
        pos_dwn_inn = edges_positions_dwn[i]
        is_first = i == 0
        is_before_last = i == num_edges - 2
        is_last = i == num_edges - 1

        # Add edge (note that we always add the first and last edge edge).
        if is_first or is_last or add_inside_edges:
            all_positions.append(interp_linear_multiple(v_ratios, pos_upp_inn, pos_dwn_inn))

        # Add in-betweens
        if is_last:  # For obvious reasons, we don't want to add any points after the last edge.
            continue

        num_inbetweens = num_inbetweens_outside if is_first or is_before_last else num_inbetweens_inside

        if num_inbetweens:
            pos_upp_out = edges_positions_upp[i+1]
            pos_dwn_out = edges_positions_dwn[i+1]
            for j in range(num_inbetweens_outside):
                ratio = float(j+1)/(num_inbetweens_outside+1)
                pos_upp = interp_linear(ratio, pos_upp_inn, pos_upp_out)
                pos_dwn = interp_linear(ratio, pos_dwn_inn, pos_dwn_out)
                all_positions.append(interp_linear_multiple(v_ratios, pos_upp, pos_dwn))

    # Add last edge
    all_positions.append(interp_linear_multiple(v_ratios, edges_positions_upp[-1], edges_positions_dwn[-1]))


    # Model the plane
    for u in range(len(all_positions)):
        for v in range(len(all_positions[u])):
            pos = all_positions[u][v]
            plane.setCV(u, v, pos)

    return plane
    def doRig(self):
        anchorList = []
        cntrlList = []
        locList = []

        dummyCrv = self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv'
        pm.hide(pm.polyCube(n=dummyCrv))

        if pm.objExists(self.ribbonDict['noMoveSetup']['nameTempl']):
            pm.delete(self.ribbonDict['noMoveSetup']['nameTempl'])

        if pm.objExists(self.ribbonDict['moveallSetup']['nameTempl']):
            pm.delete(self.ribbonDict['moveallSetup']['nameTempl'])

        logger
        ###Estrutura que nao deve ter transformacao
        noMoveSpace = pm.group(empty=True,
                               n=self.ribbonDict['noMoveSetup']['nameTempl'])
        if not pm.objExists('NOMOVE'):
            pm.group(self.ribbonDict['noMoveSetup']['nameTempl'], n='NOMOVE')
        else:
            pm.parent(self.ribbonDict['noMoveSetup']['nameTempl'], 'NOMOVE')

        pm.parent(self.ribbonDict['moveallSetup']['nameTempl'] + '_dummy_crv',
                  noMoveSpace)

        noMoveSpace.visibility.set(0)
        noMoveBend1 = pm.nurbsPlane(p=(self.size * 0.5, 0, 0),
                                    ax=(0, 0, 1),
                                    w=self.size,
                                    lr=0.1,
                                    d=3,
                                    u=5,
                                    v=1)
        # noMoveCrvJnt = pm.curve ( bezier=True, d=3, p=[(self.size*-0.5,0,0),(self.size*-0.4,0,0),(self.size*-0.1,0,0),(0,0,0),(self.size*0.1,0,0),(self.size*0.4,0,0),(self.size*0.5,0,0)], k=[0,0,0,1,1,1,2,2,2])
        noMoveCrvJnt = pm.curve(
            bezier=True,
            d=3,
            p=[(self.size * -0.50, 0, 0), (self.size * -0.499, 0, 0),
               (self.size * -0.496, 0, 0), (self.size * -0.495, 0, 0),
               (self.size * -0.395, 0, 0), (self.size * -0.10, 0, 0),
               (0, 0, 0), (self.size * 0.10, 0, 0), (self.size * 0.395, 0, 0),
               (self.size * 0.495, 0, 0), (self.size * 0.496, 0, 0),
               (self.size * 0.499, 0, 0), (self.size * 0.50, 0, 0)],
            k=[0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10, 10])

        noMoveCrvJnt.translate.set(self.size * 0.5, 0, 0)

        # Deformers das superficies noMove
        twist1 = pm.nonLinear(noMoveBend1[0],
                              type='twist')  # twist das superficies noMove
        twist1[1].rotateZ.set(90)

        # IMPLEMENTAR O TWIST DO MEIO
        twist2 = pm.nonLinear(noMoveBend1[0].name() + '.cv[0:3][0:3]',
                              type='twist')  # twist das superficies noMove
        twist2[1].rotateZ.set(90)
        twist3 = pm.nonLinear(noMoveBend1[0].name() + '.cv[4:7][0:3]',
                              type='twist')  # twist das superficies noMove
        twist3[1].rotateZ.set(90)

        wireDef = pm.wire(noMoveBend1[0], w=noMoveCrvJnt,
                          dds=[(0, 50)])  # Wire das superficies noMove
        wireDef[0].rotation.set(1)  # seta rotacao pra acontecer
        baseWire = [
            x for x in wireDef[0].connections() if 'BaseWire' in x.name()
        ]
        pm.group(baseWire,
                 noMoveCrvJnt,
                 noMoveBend1[0],
                 p=noMoveSpace,
                 n=self.name + 'Deforms_grp')
        pm.parent(twist1[1], twist2[1], twist3[1], noMoveSpace)

        ###Estrutura que pode ser movida
        cntrlsSpace = pm.group(empty=True,
                               n=self.ribbonDict['moveallSetup']['nameTempl'])
        bendSurf1 = pm.nurbsPlane(p=(self.size * -0.5, 0, 0),
                                  ax=(0, 0, 1),
                                  w=self.size * 0.5,
                                  lr=.1,
                                  d=3,
                                  u=5,
                                  v=1)

        blend1 = pm.blendShape(noMoveBend1[0], bendSurf1[0])
        pm.blendShape(blend1, e=True, w=[(0, 1)])
        pm.parent(bendSurf1[0], cntrlsSpace)

        ##Cntrls
        for i in range(0, 7):
            anchor = pm.cluster(noMoveCrvJnt.name() + '.cv[' + str(i + 3) +
                                ']')
            pm.cluster(anchor[1], e=True, g=dummyCrv)
            clsHandle = anchor[1]
            anchorGrp = pm.group(em=True, n='clusterGrp' + str(i))
            anchorDrn = pm.group(em=True, n='clusterDrn' + str(i), p=anchorGrp)
            pos = pm.xform(anchor, q=True, ws=True, rp=True)
            pm.xform(anchorGrp, t=pos, ws=True)
            pm.parent(anchor[1], anchorDrn)
            anchorList.append(anchor[1])

            if i == 0 or i == 6:
                displaySetup = self.ribbonDict['cntrlSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName,
                                              obj=anchor[1],
                                              **displaySetup)
            elif i == 3:

                displaySetup = self.ribbonDict['midCntrlSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName,
                                              obj=anchor[1],
                                              **displaySetup)

            else:
                displaySetup = self.ribbonDict['cntrlTangSetup'].copy()
                cntrlName = displaySetup['nameTempl'] + str(i)
                cntrl = controlTools.cntrlCrv(name=cntrlName,
                                              obj=anchor[1],
                                              **displaySetup)

            # Nao pode fazer conexao na criacao do controle, pois tera conexao direta
            pm.xform(cntrl.getParent(), t=pos, ws=True)

            # estrutura de buffers para conexao direta
            auxLocGrp = pm.group(em=True, n=self.name + 'auxLoc_grp')
            auxLoc = pm.group(em=True, p=auxLocGrp, n=self.name + 'aux_loc')
            pm.xform(auxLocGrp, t=pos, ws=True)
            loc = pm.PyNode(auxLoc)

            if i == 1 or i == 4:
                pm.xform(anchorGrp, s=(-1, 1, 1), r=True)
                pm.xform(cntrl.getParent(), s=(-1, 1, 1), r=True)
                pm.xform(loc.getParent(), s=(-1, 1, 1), r=True)

            # Conexoes dos buffers cm os clusters e com os controles
            pm.parentConstraint(cntrl, loc)
            loc.translate >> anchorDrn.translate
            loc.rotate >> anchorDrn.rotate
            cntrlList.append(cntrl)
            locList.append(loc)

        startCls = pm.cluster(noMoveCrvJnt.name() + '.cv[0:2]')
        endCls = pm.cluster(noMoveCrvJnt.name() + '.cv[10:14]')
        pm.cluster(startCls[1], e=True, g=dummyCrv)
        pm.cluster(endCls[1], e=True, g=dummyCrv)

        pm.parent(startCls, anchorList[0])
        pm.parent(endCls, anchorList[6])

        cntrlsSpace.addAttr('cntrlsVis', at='double', dv=1, k=True, h=False)
        cntrlsSpace.addAttr('extraCntrlsVis',
                            at='double',
                            dv=0,
                            k=True,
                            h=False)
        cntrlList[0].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[0].addAttr('stretchDist', at='double', dv=0, k=True)
        cntrlList[0].addAttr('autoVolumStregth', at='double', dv=0, k=True)
        cntrlList[3].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[3].addAttr('autoVolume', at='double', dv=0, k=True)
        cntrlList[6].addAttr('twist', at='double', dv=0, k=True)
        cntrlList[6].addAttr('stretchDist', at='double', dv=0, k=True)
        cntrlList[6].addAttr('autoVolumStregth', at='double', dv=0, k=True)

        cntrlList[0].twist >> twist1[0].endAngle
        cntrlList[3].twist >> twist2[0].startAngle
        cntrlList[3].twist >> twist3[0].endAngle
        cntrlList[6].twist >> twist1[0].startAngle

        # hierarquia
        pm.parent(anchorList[1].getParent(2), anchorList[0])
        pm.parent(anchorList[5].getParent(2), anchorList[6])
        pm.parent(anchorList[2].getParent(2), anchorList[4].getParent(2),
                  anchorList[3])
        pm.parent(cntrlList[1].getParent(), cntrlList[0])
        pm.parent(cntrlList[5].getParent(), cntrlList[6])
        pm.parent(cntrlList[2].getParent(), cntrlList[4].getParent(),
                  cntrlList[3])
        pm.parent(cntrlList[3].getParent(), cntrlList[0].getParent(),
                  cntrlList[6].getParent(), cntrlsSpace)
        pm.parent(locList[1].getParent(), locList[0])
        pm.parent(locList[5].getParent(), locList[6])
        pm.parent(locList[2].getParent(), locList[4].getParent(), locList[3])
        pm.parent(locList[3].getParent(), locList[0].getParent(),
                  locList[6].getParent(), cntrlsSpace)
        pm.parent(anchorList[3].getParent(2), anchorList[0].getParent(2),
                  anchorList[6].getParent(2), noMoveSpace)

        # Skin joints do ribbon
        skinJntsGrp = pm.group(em=True, n=self.name + 'SkinJnts_grp')
        follGrp = pm.group(em=True, n=self.name + 'Foll_grp')

        # cria ramps para controlar o perfil de squash e stretch
        ramp1 = pm.createNode('ramp', n=self.name + 'SquashRamp1')
        ramp1.attr('type').set(1)

        # ramp2 = pm.createNode ('ramp')
        # ramp2.attr('type').set(1)

        expre1 = "float $dummy = " + ramp1.name(
        ) + ".outAlpha;float $output[];float $color[];"
        # expre2 = "float $dummy = "+ramp2.name()+".outAlpha;float $output[];float $color[];"

        extraCntrlsGrp = pm.group(em=True,
                                  r=True,
                                  p=cntrlsSpace,
                                  n=self.name + 'extraCntrls_grp')

        # loop pra fazer os colocar o numero escolhido de joints ao longo do ribbon.
        # cria tmb node tree pro squash/stretch
        # e controles extras
        vIncrement = float(
            (1.0 - (self.offsetStart + self.offsetEnd)) / (self.numJnts - 1))
        for i in range(1, self.numJnts + 1):
            # cria estrutura pra superficie 1
            pm.select(cl=True)
            jntName = self.ribbonDict['jntSetup']['nameTempl'] + str(
                i) + self.jntSulfix
            jnt1 = pm.joint(p=(0, 0, 0), n=jntName)
            self.skinJoints.append(jnt1)
            displaySetup = self.ribbonDict['cntrlExtraSetup'].copy()
            cntrlName = displaySetup['nameTempl'] + 'A' + str(i)
            cntrl1 = controlTools.cntrlCrv(name=cntrlName,
                                           obj=jnt1,
                                           connType='parentConstraint',
                                           **displaySetup)

            # node tree
            blend1A = pm.createNode('blendTwoAttr',
                                    n=self.name + 'VolumeBlend1A')
            blend1B = pm.createNode('blendTwoAttr',
                                    n=self.name + 'VolumeBlend1B')
            gammaCorr1 = pm.createNode('gammaCorrect',
                                       n=self.name + 'VolumeGamma1')
            cntrlList[0].attr('autoVolumStregth') >> gammaCorr1.gammaX
            cntrlList[0].attr('stretchDist') >> gammaCorr1.value.valueX
            blend1A.input[0].set(1)
            gammaCorr1.outValueX >> blend1A.input[1]
            blend1B.input[0].set(1)
            blend1A.output >> blend1B.input[1]
            cntrlList[3].attr('autoVolume') >> blend1B.attributesBlender
            blend1B.output >> cntrl1.getParent().scaleY
            blend1B.output >> cntrl1.getParent().scaleZ
            # expressao que le a rampa para setar valores da escala de cada joint quando fizer squash/stretch
            expre1 = expre1 + "$color = `colorAtPoint -o RGB -u " + str(
                self.offsetStart +
                (i - 1) * vIncrement) + " -v 0.5 " + ramp1.name(
                ) + " `;$output[" + str(i) + "] = $color[0];" + blend1A.name(
                ) + ".attributesBlender=$output[" + str(i) + "];"

            # prende joints nas supeficies com follicules
            foll1 = self.attachObj(cntrl1.getParent(), bendSurf1[0],
                                   self.offsetStart + (i - 1) * vIncrement,
                                   0.5, 4)

            pm.parent(cntrl1.getParent(), extraCntrlsGrp)
            pm.parent(jnt1, skinJntsGrp)
            pm.parent(foll1, follGrp)

            # seta expressoes para so serem avaliadas por demanda
        pm.expression(s=expre1, ae=False)

        pm.parent(skinJntsGrp, cntrlsSpace)
        pm.parent(follGrp, noMoveSpace)

        # hideCntrls
        pm.toggle(bendSurf1[0], g=True)
        bendSurf1[0].visibility.set(0)

        # skinJntsGrp.visibility.set(0)
        cntrlsSpace.extraCntrlsVis >> extraCntrlsGrp.visibility
        cntrlsSpace.cntrlsVis >> cntrlList[0].getParent().visibility
        cntrlsSpace.cntrlsVis >> cntrlList[3].getParent().visibility
        cntrlsSpace.cntrlsVis >> cntrlList[6].getParent().visibility

        # povoa ribbon Dict
        self.ribbonDict['name'] = 'bezierRibbon'
        self.ribbonDict['ribbonMoveAll'] = cntrlsSpace
        for i in range(0, 7):
            self.ribbonDict['cntrl' + str(i)] = cntrlList[i]
        self.startCntrl = cntrlList[0]
        self.midCntrl = cntrlList[3]
        self.endCntrl = cntrlList[6]
        self.moveall = cntrlsSpace
Exemple #47
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]