Ejemplo n.º 1
0
 def sqCreateStikyLipsDeformers(self, *args):
     baseMesh = None
     mainCurveList = [self.mainCurveA, self.mainCurveB]
     for mainCurve in mainCurveList:
         if baseMesh == None:
             baseMesh = cmds.duplicate(self.receptList[0], name=self.receptList[0]+"Base")[0]
             cmds.setAttr(baseMesh+".visibility", 0)
         
         wrapNode = cmds.deformer(mainCurve, name="StickyLips_Wrap", type="wrap")[0]
         try:
             cmds.connectAttr(self.receptList[0]+".dropoff", wrapNode+".dropoff[0]", force=True)
             cmds.connectAttr(self.receptList[0]+".inflType", wrapNode+".inflType[0]", force=True)
             cmds.connectAttr(self.receptList[0]+".smoothness", wrapNode+".smoothness[0]", force=True)
             cmds.connectAttr(self.receptList[0]+"Shape.worldMesh[0]", wrapNode+".driverPoints[0]", force=True)
         except:
             pass
         
         cmds.connectAttr(baseMesh+"Shape.worldMesh[0]", wrapNode+".basePoints[0]", force=True)
         cmds.connectAttr(mainCurve+"Shape.worldMatrix[0]", wrapNode+".geomMatrix", force=True)
         cmds.setAttr(wrapNode+".maxDistance", 1)
         cmds.setAttr(wrapNode+".autoWeightThreshold", 1)
         cmds.setAttr(wrapNode+".exclusiveBind", 1)
         
     baseCurveList = [self.baseCurveA, self.baseCurveB]
     for c, baseCurve in enumerate(baseCurveList):
         wireNode = cmds.wire(self.receptList[1], name=baseCurve+"_Wire", groupWithBase=False, crossingEffect=0, localInfluence=0)[0]
         cmds.connectAttr(mainCurveList[c]+"Shape.worldSpace[0]", wireNode+".baseWire[0]", force=True)
         cmds.connectAttr(baseCurve+"Shape.worldSpace[0]", wireNode+".deformedWire[0]", force=True)
         self.wireNodeList.append(wireNode)
         
         wireLocList = []
         for i in range(0, self.maxIter):
             wireLocList.append(baseCurve+".u["+str(i)+"]")
         cmds.dropoffLocator(1, 1, wireNode, wireLocList)
Ejemplo n.º 2
0
    def sqCreateStikyLipsDeformers(self, *args):
        baseMesh = None
        mainCurveList = [self.mainCurveA, self.mainCurveB]
        for mainCurve in mainCurveList:
            if baseMesh == None:
                baseMesh = cmds.duplicate(self.receptList[0],
                                          name=self.receptList[0] + "Base")[0]
                cmds.setAttr(baseMesh + ".visibility", 0)

            wrapNode = cmds.deformer(mainCurve,
                                     name="StickyLips_Wrap",
                                     type="wrap")[0]
            try:
                cmds.connectAttr(self.receptList[0] + ".dropoff",
                                 wrapNode + ".dropoff[0]",
                                 force=True)
                cmds.connectAttr(self.receptList[0] + ".inflType",
                                 wrapNode + ".inflType[0]",
                                 force=True)
                cmds.connectAttr(self.receptList[0] + ".smoothness",
                                 wrapNode + ".smoothness[0]",
                                 force=True)
                cmds.connectAttr(self.receptList[0] + "Shape.worldMesh[0]",
                                 wrapNode + ".driverPoints[0]",
                                 force=True)
            except:
                pass

            cmds.connectAttr(baseMesh + "Shape.worldMesh[0]",
                             wrapNode + ".basePoints[0]",
                             force=True)
            cmds.connectAttr(mainCurve + "Shape.worldMatrix[0]",
                             wrapNode + ".geomMatrix",
                             force=True)
            cmds.setAttr(wrapNode + ".maxDistance", 1)
            cmds.setAttr(wrapNode + ".autoWeightThreshold", 1)
            cmds.setAttr(wrapNode + ".exclusiveBind", 1)

        baseCurveList = [self.baseCurveA, self.baseCurveB]
        for c, baseCurve in enumerate(baseCurveList):
            wireNode = cmds.wire(self.receptList[1],
                                 name=baseCurve + "_Wire",
                                 groupWithBase=False,
                                 crossingEffect=0,
                                 localInfluence=0)[0]
            cmds.connectAttr(mainCurveList[c] + "Shape.worldSpace[0]",
                             wireNode + ".baseWire[0]",
                             force=True)
            cmds.connectAttr(baseCurve + "Shape.worldSpace[0]",
                             wireNode + ".deformedWire[0]",
                             force=True)
            self.wireNodeList.append(wireNode)

            wireLocList = []
            for i in range(0, self.maxIter):
                wireLocList.append(baseCurve + ".u[" + str(i) + "]")
            cmds.dropoffLocator(1, 1, wireNode, wireLocList)
Ejemplo n.º 3
0
    def rebuild(self):
        """
        Rebuild the wire deformer from the recorded deformerData
        """
        # ==========
        # - Checks -
        # ==========

        # Check Data
        for influence in self._influenceData.iterkeys():

            # Check Wire Curve
            if not cmds.objExists(influence):
                print('Wire curve "' + influence + '" does not exist! Curve will not be added to deformer!')

            # Check Base Curves
            baseCurve = self._influenceData[influence]['influenceBase']
            if not cmds.objExists(baseCurve):
                print(
                'Wire curve base "' + baseCurve + '" does not exist! A static base curve will be generated from the deforming wire curve!')

        # Check Dropoff Locators
        for locator in self._locatorData.iterkeys():
            if cmds.objExists(locator):
                cmds.delete(cmds.listRelatives(locator, p=True)[0])

        # ====================
        # - Rebuild Deformer -
        # ====================

        result = super(WireData, self).rebuild()
        wireDeformer = result['deformer']

        # =======================
        # - Connect Wire Curves -
        # =======================

        for influence in self._influenceData.iterkeys():

            # Get current wire curve pair
            wireCurve = influence
            infIndex = self._influenceData[influence]['index']
            baseCurve = self._influenceData[influence]['influenceBase']

            # Connect deformed wire
            if not cmds.objExists(influence): continue
            cmds.connectAttr(wireCurve + '.worldSpace[0]', wireDeformer + '.deformedWire[' + str(infIndex) + ']', f=True)

            # Connect base wire
            if not cmds.objExists(baseCurve): baseCurve = cmds.duplicate(influence, n=baseCurve)[0]
            cmds.connectAttr(baseCurve + '.worldSpace[0]', wireDeformer + '.baseWire[' + str(infIndex) + ']', f=True)
            cmds.setAttr(baseCurve + '.v', 0)

            # Set Influence Attributes
            if cmds.getAttr(wireDeformer + '.dropoffDistance[' + str(infIndex) + ']', se=True):
                cmds.setAttr(wireDeformer + '.dropoffDistance[' + str(infIndex) + ']',
                           self._influenceData[influence]['dropoffDist'])
            if cmds.getAttr(wireDeformer + '.scale[' + str(infIndex) + ']', se=True):
                cmds.setAttr(wireDeformer + '.scale[' + str(infIndex) + ']', self._influenceData[influence]['scale'])

        # ============================
        # - Rebuild Dropoff Locators -
        # ============================

        for locator in self._locatorData.iterkeys():
            # Get data
            parent = self._locatorData[locator]['parent']
            param = self._locatorData[locator]['parameter']
            env = self._locatorData[locator]['envelope']
            percent = self._locatorData[locator]['percent']
            twist = self._locatorData[locator]['twist']

            # Create Locator
            loc = cmds.dropoffLocator(env, percent, wire, parent + '.u[' + str(param) + ']')[0]

            # Apply Twist
            locConn = cmds.listConnections(loc + '.param', s=False, d=True, p=True)[0]
            locConnIndex = locConn.split('[')[-1].split(']')[0]
            cmds.setAttr(wireDeformer + '.wireLocatorTwist[' + str(locConnIndex) + ']', twist)

        # =================
        # - Return Result -
        # =================

        self.result['influence'] = self._influenceData.keys()
        self.result['dropoffLocator'] = self._locatorData.keys()

        return self.result
Ejemplo n.º 4
0
def dropoffLocator(*args, **kwargs):
    res = cmds.dropoffLocator(*args, **kwargs)
    if not kwargs.get('query', kwargs.get('q', False)):
        res = _factories.maybeConvert(res, _general.PyNode)
    return res
Ejemplo n.º 5
0
cmds.delete(cmds.orientConstraint(startLoc, sPlane))
cmds.delete(sPlane, constructionHistory=True)

sCurve = cmds.curve(degree=1, point=[startPoint, endPoint])
sCurve = cmds.rename(
    sCurve, un + 'stretchCurve'
)  # If named at the creation time, the shape node doesn't get renamed

cmds.parent(startLoc, endLoc, sPlane[0], sCurve, sGrp)

# create wire deformer and dropoffLocator for twisting
sWire = cmds.wire(sPlane[0], wire=sCurve, name=un + 'stretchWire')
cmds.wire(sWire[1], edit=True, dropoffDistance=[(0, 20), (1, 20)])

cmds.select(sWire[1] + '.u[0]', r=True)
cmds.dropoffLocator(1.0, 1.0, sWire[0])
cmds.select(sWire[1] + '.u[1]', r=True)
cmds.dropoffLocator(1.0, 1.0, sWire[0])

# skin wire to bone driver, connect rotation of locators to drop off locators twist

cmds.connectAttr(startLoc[0] + '.rotateX', sWire[0] + '.wireLocatorTwist[0]')
cmds.connectAttr(endLoc[0] + '.rotateX', sWire[0] + '.wireLocatorTwist[1]')

cmds.skinCluster(startWJoint,
                 endWJoint,
                 sWire[1],
                 maximumInfluences=1,
                 toSelectedBones=True)

# crating follicles on sPlane and joints
Ejemplo n.º 6
0
def make_stretch_plane(prefix='',
                       start_joint=cmds.ls(selection=True)[0],
                       end_joint=cmds.listRelatives(start_joint)[0],
                       number_of_bones=3,
                       stretch_len=cmds.getAttr(end_joint + '.translateX')):
    """
    :param prefix: str, name of objects
    :param start_joint: str, start point of stretch plane and parent bone
    :param end_joint: str, end point of stretch plane (right now its just the child of the start joint)
    :param number_of_bones: float, how many bones will be placed along the length of the plane
    :param stretch_len: float, the length of the plane, from start joint to end joint
    :return: list[], containing all stretch joints for skinning
    """

    # TODO need to get actual distance between points for spine

    start_point = cmds.xform(start_joint,
                             query=True,
                             worldSpace=True,
                             translation=True)
    end_point = cmds.xform(end_joint,
                           query=True,
                           worldSpace=True,
                           translation=True)

    # create start + end locators, bones to skin the wire to, and an empty group
    start_loc = cmds.spaceLocator(name='start_loc')
    cmds.parent(start_loc, start_joint, relative=True)
    end_loc = cmds.spaceLocator(name='end_loc')
    cmds.parent(end_loc, end_joint, relative=True)

    start_w_joint = cmds.joint(name='startWireJoint')
    cmds.parent(start_w_joint, start_loc)
    end_w_joint = cmds.joint(name='endWireJoint')
    cmds.parent(end_w_joint, end_loc)

    s_grp = cmds.group(empty=True, name=prefix + 'stretchPlaneGrp')
    cmds.delete(cmds.parentConstraint(start_loc, s_grp))

    # create NURBS plane and CV curve. Group everything into the new sGrp
    s_plane = cmds.nurbsPlane(name=prefix + 'stretchPlane',
                              width=stretch_len,
                              lengthRatio=.2,
                              patchesU=number_of_bones,
                              axis=(0, 1, 0))
    s_plane_shape = cmds.listRelatives(s_plane, shapes=True)[0]
    cmds.delete(cmds.parentConstraint(start_loc, end_loc, s_plane))
    cmds.delete(cmds.orientConstraint(start_loc, s_plane))
    cmds.delete(s_plane, constructionHistory=True)

    s_curve = cmds.curve(degree=1, point=[start_point, end_point])
    s_curve = cmds.rename(
        s_curve, prefix + 'stretchCurve'
    )  # If named at the creation time, the shape node doesn't get renamed

    cmds.parent(start_loc, end_loc, s_plane[0], s_curve, s_grp)

    # create wire deformer and dropoffLocator for twisting
    s_wire_deform = cmds.wire(s_plane[0],
                              wire=s_curve,
                              name=prefix + 'stretchWire')[0]
    cmds.wire(s_curve, edit=True, dropoffDistance=[(0, 20), (1, 20)])

    cmds.select(s_curve + '.u[0]', r=True)
    cmds.dropoffLocator(1.0, 1.0, s_wire_deform)
    cmds.select(s_curve + '.u[1]', r=True)
    cmds.dropoffLocator(1.0, 1.0, s_wire_deform)

    # connect rotation of locators to drop off locators twist, skin wire to bone driver

    cmds.connectAttr(start_loc[0] + '.rotateX',
                     s_wire_deform + '.wireLocatorTwist[0]')
    cmds.connectAttr(end_loc[0] + '.rotateZ',
                     s_wire_deform + '.wireLocatorTwist[1]')

    cmds.skinCluster(start_w_joint,
                     end_w_joint,
                     s_curve,
                     maximumInfluences=1,
                     toSelectedBones=True)

    # crating follicles on sPlane and joints

    s_joints_collection = []
    fol_grp = cmds.group(empty=True, name=prefix + 'follicleGrp')
    cmds.parent(fol_grp, s_grp)

    for x in range(number_of_bones):
        fol_shape = cmds.createNode("follicle")
        fol_trans = cmds.listRelatives(fol_shape, parent=True)[0]
        fol_trans = cmds.rename(fol_trans,
                                prefix + "follicle_{:02d}".format(x + 1))
        fol_shape = cmds.listRelatives(fol_trans, shapes=True)[0]
        fol_shape = cmds.rename(fol_shape,
                                prefix + "follicleShape_{:02d}".format(x + 1))

        cmds.connectAttr(s_plane_shape + '.worldMatrix[0]',
                         fol_shape + '.inputWorldMatrix')
        cmds.connectAttr(s_plane_shape + '.local', fol_shape + '.inputSurface')
        cmds.connectAttr(fol_shape + '.outTranslate', fol_trans + '.translate')
        cmds.connectAttr(fol_shape + '.outRotate', fol_trans + '.rotate')

        v_position = (1.0 / (number_of_bones + 1)) * (x + 1)
        cmds.setAttr(fol_shape + '.parameterU', v_position)
        cmds.setAttr(fol_shape + '.parameterV', .5)

        # here I'm adding a joint, as the follicle is selected the joint is parented under it.
        # im also adding the joint to a list i can use later
        s_joints_collection.append(
            cmds.joint(name=prefix + "stretchJoint_{:02d}".format(x + 1)))

        cmds.parent(fol_trans, fol_grp)

    # creating nodes for stretching bones
    s_curve_shape = cmds.listRelatives(s_curve, shapes=True)[0]
    s_curve_info = cmds.createNode('curveInfo', name='SCurveInfo')
    cmds.rename(s_curve_info, 'SCurveInfo')
    cmds.connectAttr(s_curve_shape + '.worldSpace[0]',
                     s_curve_info + '.inputCurve')

    joint_scale = cmds.createNode('multiplyDivide', name='sJointScale')
    cmds.setAttr(joint_scale + '.operation', 2)
    cmds.setAttr(joint_scale + '.input2X', stretch_len)
    cmds.connectAttr(s_curve_info + '.arcLength', joint_scale + '.input1X')

    # connecting up nodes to bones
    for joint in s_joints_collection:
        cmds.connectAttr(joint_scale + '.outputX', joint + '.scaleX')

    # creating a variable for the base wire of the wire deformer
    s_base_wire = cmds.listConnections(s_wire_deform + ".baseWire",
                                       destination=False,
                                       source=True)[0]

    # creating group inorder to help organisation and prevent double transforms
    s_rig_grp = cmds.group(empty=True, name=prefix + 'stretchPlaneRigGrp')
    align(start_joint, s_rig_grp)

    cmds.parent(s_rig_grp, s_grp)
    cmds.parent(s_plane[0], s_base_wire, start_loc, end_loc, s_rig_grp)
    cmds.setAttr(start_w_joint + ".visibility", False)
    cmds.setAttr(end_w_joint + ".visibility", False)

    # Connecting end locators to driving joints -will have to do this properly in the main script
    cmds.pointConstraint(end_joint, end_loc)
    cmds.connectAttr(
        end_joint + '.rotateZ', end_loc[0] +
        '.rotateZ')  # TODO: add if statment for elbow/wrist rotations
    cmds.parent(s_rig_grp, start_joint)

    return s_joints_collection
Ejemplo n.º 7
0
def createCtrlSys(crv,
                  rootCrv,
                  surface,
                  rootSurface,
                  name,
                  parameter=0.5,
                  iteration=1):
    # Get surface shape
    crv_shape = cmds.listRelatives(crv[0], type="shape")[0]
    rootCrv_shape = cmds.listRelatives(rootCrv[0], type="shape")[0]

    surface_shape = cmds.listRelatives(surface[0], type="shape")
    rootSurface_shape = cmds.listRelatives(rootSurface[0], type="shape")

    # create wire, cluster
    wire = cmds.wire(surface,
                     gw=False,
                     en=1.0,
                     ce=0.0,
                     li=0.0,
                     dds=(0, 1000),
                     w=crv,
                     n=name + "_wire")[0]
    newCluster = cmds.cluster(rootCrv[0] + '.cv[:]',
                              n="{}_{}_FreeSys_Crv_Clst".format(
                                  name, iteration),
                              envelope=1)
    # run dynamicClst script
    cmds.select(rootCrv[0], r=1)
    dynamicSys_data = tp_createDynamicClst()
    cmds.select(cl=1)

    # Get arc length
    rootCrv_arcLength = cmds.arclen(rootCrv)

    # Create control
    ctrl_data = bd_buildCtrl(ctrl_type="sphere",
                             name="{}_{}".format(name, iteration),
                             sufix="_FreeSys_Ctrl",
                             offset=1)
    # Create follicle on surface
    follicle_data = createFollicle(inputSurface=rootSurface_shape,
                                   name=name + '_FreeSys_Ctrl_Flc',
                                   hide=0)
    # Point constraint ctrl grp
    cmds.pointConstraint(follicle_data[0],
                         ctrl_data[1],
                         offset=(0, 0, 0),
                         weight=1)
    # Orient constroint ctrl
    cmds.orientConstraint(follicle_data[0], ctrl_data[0], mo=1, weight=1)
    # Create attributes on control - Division, Parameter, Twist, Interpotaion
    cmds.addAttr(ctrl_data[0],
                 ln="customAttr",
                 nn="________",
                 at="enum",
                 en="Custom:",
                 keyable=True)
    cmds.setAttr(ctrl_data[0] + ".customAttr", lock=1)
    cmds.addAttr(ctrl_data[0],
                 ln="parameter",
                 nn="Parameter",
                 at="double",
                 min=0,
                 max=rootCrv_arcLength,
                 dv=(rootCrv_arcLength / 2),
                 keyable=True)
    cmds.addAttr(ctrl_data[0],
                 ln="twist",
                 nn="Twist",
                 at="double",
                 min=-1000,
                 max=1000,
                 dv=0,
                 keyable=True)
    cmds.addAttr(ctrl_data[0],
                 ln="interpolation",
                 nn="Interpolation",
                 at="long",
                 min=1,
                 max=6,
                 dv=4,
                 keyable=True)
    cmds.connectAttr(ctrl_data[0] + ".interpolation",
                     dynamicSys_data[0] + ".interpolation")

    # Create setRange for translate conversion 0 1
    ctrl_setRange = cmds.shadingNode('setRange',
                                     au=1,
                                     n=name + '_ctrl_t_setRange')
    cmds.setAttr(ctrl_setRange + '.max.maxX', 1)
    cmds.setAttr(ctrl_setRange + '.oldMax.oldMaxX', rootCrv_arcLength)
    cmds.connectAttr(ctrl_data[0] + '.parameter',
                     ctrl_setRange + '.value.valueX')

    # Connect ctrl translate x to follicle uVlue
    cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
                     follicle_data[1] + '.parameterU')

    # Create set range for scale X, output max 0-1, control ramp falloff
    scale_setRange = cmds.shadingNode('setRange',
                                      au=1,
                                      n=name + '_ctrl_scaleToFalloff_setRange')
    cmds.setAttr(scale_setRange + '.oldMin.oldMinX', 0.2)
    cmds.setAttr(scale_setRange + '.oldMax.oldMaxX', 5)
    cmds.setAttr(scale_setRange + '.min.minX', 0.1)
    cmds.setAttr(scale_setRange + '.max.maxX', 1)

    cmds.connectAttr(ctrl_data[0] + '.scale.scaleX',
                     scale_setRange + '.value.valueX')

    # Calcaulating start and end position
    colorStart_mpDiv = cmds.shadingNode('multiplyDivide',
                                        au=1,
                                        n=name + '_scaleInvert_mpDivide')
    colorStartEnd_plusMA = cmds.shadingNode('plusMinusAverage',
                                            au=1,
                                            n=name + '_falloffResult_plusMA')

    # Invert Scale newRange value
    cmds.setAttr(colorStart_mpDiv + '.input2.input2X', -1)
    cmds.connectAttr(scale_setRange + '.outValue.outValueX',
                     colorStart_mpDiv + '.input1.input1X')

    # Connect to plusMinusAvarege node
    cmds.connectAttr(colorStart_mpDiv + '.output.outputX',
                     colorStartEnd_plusMA + '.input2D[0].input2Dx')
    cmds.connectAttr(scale_setRange + '.outValue.outValueX',
                     colorStartEnd_plusMA + '.input2D[0].input2Dy')

    cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
                     colorStartEnd_plusMA + '.input2D[1].input2Dx')
    cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
                     colorStartEnd_plusMA + '.input2D[1].input2Dy')

    # Create clamp setRange - Limiting calculation to 0 to 1
    clamp_setRenge = cmds.shadingNode('setRange',
                                      au=1,
                                      n=name + '_resultClamp_setRange')
    cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxX', 1)
    cmds.setAttr(clamp_setRenge + '.max.maxX', 1)
    cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxY', 1)
    cmds.setAttr(clamp_setRenge + '.max.maxY', 1)
    cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dx',
                     clamp_setRenge + '.value.valueX')
    cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dy',
                     clamp_setRenge + '.value.valueY')

    # Connect to ramp colors
    # Connect and configure color 1 mid
    cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
                     dynamicSys_data[0] + '.colorEntryList[0].position')
    cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[0].color',
                 1,
                 1,
                 1,
                 type="double3")

    # Connect and configure color 0 start
    cmds.connectAttr(clamp_setRenge + '.outValue.outValueX',
                     dynamicSys_data[0] + '.colorEntryList[2].position')
    cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[2].color',
                 0,
                 0,
                 0,
                 type="double3")

    # Connect and configure color 2 end
    cmds.connectAttr(clamp_setRenge + '.outValue.outValueY',
                     dynamicSys_data[0] + '.colorEntryList[1].position')
    cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[1].color',
                 0,
                 0,
                 0,
                 type="double3")

    # Connect ctrl to cluster
    cmds.connectAttr(ctrl_data[0] + '.translate', newCluster[1] + '.translate')

    # Create and connect dropoff locators
    cmds.select("{}.u[{}]".format(crv[0], 0), r=True)
    dropoffLoc1 = cmds.dropoffLocator(1.0, 1.0, wire)[0]

    cmds.select("{}.u[{}]".format(crv[0], 0.1), r=True)
    dropoffLoc2 = cmds.dropoffLocator(1.0, 1.0, wire)[0]

    cmds.select("{}.u[{}]".format(crv[0], 0.2), r=True)
    dropoffLoc3 = cmds.dropoffLocator(1.0, 1.0, wire)[0]
    cmds.select(cl=1)

    cmds.connectAttr(ctrl_data[0] + ".twist",
                     "{}.wireLocatorTwist[{}]".format(wire, 1))
    cmds.connectAttr(ctrl_setRange + '.outValue.outValueX',
                     dropoffLoc2 + '.param')
    cmds.connectAttr(clamp_setRenge + '.outValue.outValueX',
                     dropoffLoc1 + '.param')
    cmds.connectAttr(clamp_setRenge + '.outValue.outValueY',
                     dropoffLoc3 + '.param')
    lock_hide([ctrl_data[0]], [".rx", ".ry", ".rz"])

    # Set control parameter of choice
    ctrl_tergetPosition = rootCrv_arcLength * parameter
    cmds.setAttr(ctrl_data[0] + '.parameter', ctrl_tergetPosition)

    # Group everything or pass creations to master grouper
    return newCluster[1], ctrl_data[1], follicle_data[0], ctrl_data[0]
Ejemplo n.º 8
0
def createBaseCtrl(crv, surface, name, color1, color2):
    # Wire surface to curve
    wire = cmds.wire(surface,
                     gw=False,
                     en=1.0,
                     ce=0.0,
                     li=0.0,
                     dds=(0, 100),
                     w=crv,
                     n=name + "_wire")[0]
    cmds.setAttr(wire + ".rotation", 0)

    # Create clusters from all cv's on curve and relative dynamic systems
    cluster_start = cmds.cluster(crv[0] + '.cv[:]',
                                 n=name + '_Start_Crv_Clst',
                                 envelope=1)
    cmds.select(crv[0], r=1)
    dynSys_start_data = tp_createDynamicClst()

    cluster_end = cmds.cluster(crv[0] + '.cv[:]',
                               n=name + '_End_Crv_Clst',
                               envelope=1)
    cmds.select(crv[0], r=1)
    dynSys_end_data = tp_createDynamicClst()

    # Adjust dynamic system ramp for start and end controls
    adjustRamp(dynSys_start_data[0],
               inPos=0,
               outPos=1,
               createMid=0,
               inColor=1,
               outColor=0)
    adjustRamp(dynSys_end_data[0],
               inPos=0,
               outPos=1,
               createMid=0,
               inColor=0,
               outColor=1)

    # Create controls - get resulting return data
    ctrl_start_data = bd_buildCtrl(ctrl_type="cube",
                                   scale=2,
                                   name=name + '_Start')
    setCtrlColor(ctrl_start_data[0], color=color1)
    ctrl_end_data = bd_buildCtrl(ctrl_type="cube", scale=2, name=name + '_End')
    setCtrlColor(ctrl_end_data[0], color=color2)

    # Get start and end point on curve positions
    # Position ctrl groups at start and end
    start_position = cmds.pointOnCurve(crv, pr=0, p=1)
    end_position = cmds.pointOnCurve(crv, pr=1, p=1)

    cmds.xform(ctrl_start_data[1], t=start_position)
    cmds.xform(ctrl_end_data[1], t=end_position)

    # Connect controls to clusters
    # Leaving X rotation out - Will be controlled by wire dropoff locators
    cmds.connectAttr(ctrl_start_data[0] + '.translate',
                     cluster_start[1] + '.translate')
    cmds.connectAttr(ctrl_start_data[0] + '.rotate.rotateY',
                     cluster_start[1] + '.rotate.rotateY')
    cmds.connectAttr(ctrl_start_data[0] + '.rotate.rotateZ',
                     cluster_start[1] + '.rotate.rotateZ')

    cmds.connectAttr(ctrl_end_data[0] + '.translate',
                     cluster_end[1] + '.translate')
    cmds.connectAttr(ctrl_end_data[0] + '.rotate.rotateY',
                     cluster_end[1] + '.rotate.rotateY')
    cmds.connectAttr(ctrl_end_data[0] + '.rotate.rotateZ',
                     cluster_end[1] + '.rotate.rotateZ')

    # Add interpolation control attribute to start/end control
    cmds.addAttr(ctrl_start_data[0],
                 ln="customAttr",
                 nn="________",
                 at="enum",
                 en="Custom:",
                 keyable=True)
    cmds.setAttr(ctrl_start_data[0] + ".customAttr", lock=1)
    cmds.addAttr(ctrl_start_data[0],
                 ln="interpolation",
                 nn="Interpolation",
                 at="long",
                 min=1,
                 max=6,
                 dv=1,
                 keyable=True)
    cmds.connectAttr(ctrl_start_data[0] + ".interpolation",
                     dynSys_start_data[0] + ".interpolation")

    cmds.addAttr(ctrl_end_data[0],
                 ln="customAttr",
                 nn="________",
                 at="enum",
                 en="Custom:",
                 keyable=True)
    cmds.setAttr(ctrl_end_data[0] + ".customAttr", lock=1)
    cmds.addAttr(ctrl_end_data[0],
                 ln="interpolation",
                 nn="Interpolation",
                 at="long",
                 min=1,
                 max=6,
                 dv=1,
                 keyable=True)
    cmds.connectAttr(ctrl_end_data[0] + ".interpolation",
                     dynSys_end_data[0] + ".interpolation")

    # Ends rotation control
    # Create dropoff locators - start end
    # Connect to controls rotation
    cmds.select("{}.u[{}]".format(crv[0], 0), r=True)
    dropoffLoc_start = cmds.dropoffLocator(1.0, 1.0, wire)[0]
    cmds.connectAttr(ctrl_start_data[0] + ".rx",
                     "{}.wireLocatorTwist[{}]".format(wire, 0))

    cmds.select("{}.u[{}]".format(crv[0], 1), r=True)
    dropoffLoc_end = cmds.dropoffLocator(1.0, 1.0, wire)[0]
    cmds.connectAttr(ctrl_end_data[0] + ".rx",
                     "{}.wireLocatorTwist[{}]".format(wire, 1))

    # return [0] ctrl 1 transform, [1] ctrl 1 grp, [2] ctrl 2 transform, [3] ctrl 2 grps, [4] cluster 1, [5] cluster 2
    return ctrl_start_data[0], ctrl_start_data[1], ctrl_end_data[
        0], ctrl_end_data[1], cluster_start, cluster_end
Ejemplo n.º 9
0
def ribbonize(surf_tr,
              equal=1,
              num_of_ctrls=5,
              num_of_jnts=29,
              prefix="",
              constrain=1,
              add_fk=0,
              wire=0):

    attrs = [
        ".tx", ".ty", ".tz", ".rx", ".ry", ".rz", ".sx", ".sy", ".sz", ".v"
    ]

    if prefix == "":
        mc.warning("te importa nombrarlo?")
        return

    else:
        prefix = prefix + "_"

    #####################################################

    surf_tr = mc.rename(surf_tr, prefix + "ribbon_surface")
    surf = mc.listRelatives(surf_tr, shapes=True)[0]

    # Congelar transformaciones y borrar el historial de superficies.
    mc.makeIdentity(surf_tr, t=True, r=True, s=True, apply=True)
    mc.delete(surf_tr, ch=True)

    # duplicar la superficie curvas para determinar la direccion.
    u_curve = mc.duplicateCurve(surf_tr + ".v[.5]", local=True, ch=0)
    v_curve = mc.duplicateCurve(surf_tr + ".u[.5]", local=True, ch=0)

    # borro historial solo porsiaca.
    mc.delete(surf_tr, ch=True)

    u_length = mc.arclen(u_curve)
    v_length = mc.arclen(v_curve)

    if u_length < v_length:
        mc.reverseSurface(surf_tr, d=3, ch=False, rpo=True)
        mc.reverseSurface(surf_tr, d=0, ch=False, rpo=True)

    parameter = ".parameterU"
    other_param = ".parameterV"

    # corrija u_curve despues de invertir para calcular la longitud.
    u_curve_corr = mc.duplicateCurve(surf_tr + ".v[.5]", local=True, ch=0)[0]

    #############################################################################

    # La superficie seleccionada es periodica o abierta? (cilindro o plano)
    if mc.getAttr(surf + ".formU") == 2 or mc.getAttr(surf + ".formV") == 2:
        curve_type = "periodic"
        divider_for_ctrls = num_of_ctrls
    elif mc.getAttr(surf + ".formU") == 0 or mc.getAttr(surf + ".formV") == 0:
        curve_type = "open"
        divider_for_ctrls = num_of_ctrls - 1

    #############################################################################
    param_ctrls = param_from_length(u_curve_corr, num_of_ctrls, curve_type,
                                    "uv")
    param_joints = param_from_length(u_curve_corr, num_of_jnts, curve_type,
                                     "uv")

    length = mc.arclen(u_curve_corr)
    mc.delete(u_curve, v_curve, u_curve_corr)

    ############################################################################

    # Creo grupos, Control General y control general de offset
    final_group = mc.group(n=prefix + "ribbon_grp", em=True)
    ctrl_joints_grp = mc.group(n=prefix + "ctrl_joints_grp", em=True)
    ctrl_grp = mc.group(n=prefix + "ctrls_grp", em=True)
    follicles_grp = mc.group(n=prefix + "follicles_grp", em=True)
    rig_grp = mc.group(n=prefix + "rig_grp", em=True)
    main_ctrl = mc.circle(n=prefix + "ctrl_main",
                          nr=(0, 1, 0),
                          r=length / 5,
                          ch=0)[0]
    main_ctrl_offset = mc.group(n=prefix + "ctrl_main_offset", em=True)

    mc.parent(main_ctrl, main_ctrl_offset)
    mc.parent(ctrl_grp, main_ctrl)
    mc.parent(main_ctrl_offset, rig_grp, final_group)
    mc.parent(surf_tr, ctrl_joints_grp, follicles_grp, rig_grp)

    # Muevo main_ctrl_offset al centro de la geometria bbox (en caso de que el pivote este en otro lugar)
    mid_point = get_bbox_center(surf_tr)
    for attr, mid_pnt_el in izip(attrs[:3], mid_point):
        mc.setAttr(main_ctrl_offset + attr, mid_pnt_el)

    ############################################################################

    fols = []
    fols_tr = []
    bind_jnts = []
    bnd_joints_rad = (length / 60) / (float(num_of_jnts) / 40)

    for x in range(num_of_jnts):

        fol = mc.createNode("follicle")
        mc.setAttr(fol + ".visibility", 0)
        temp_fol = mc.listRelatives(fol, p=True)[0]
        fols_tr.append(
            mc.rename(temp_fol, "{}follicle_{:02d}".format(prefix, x + 1)))
        fols.append(mc.listRelatives(fols_tr[-1], s=True)[0])

        # conecto follicle shapes al transform
        mc.connectAttr(fols[-1] + ".outTranslate",
                       fols_tr[-1] + ".translate",
                       f=True)
        mc.connectAttr(fols[-1] + ".outRotate",
                       fols_tr[-1] + ".rotate",
                       f=True)

        # atacho follicle shapes a la superficie
        mc.connectAttr(surf + ".worldMatrix[0]",
                       fols[-1] + ".inputWorldMatrix")
        mc.connectAttr(surf + ".local", fols[-1] + ".inputSurface")

        mc.setAttr(fols[-1] + parameter, param_joints[x])
        mc.setAttr(fols[-1] + other_param, 0.5)

        mc.parent(fols_tr[-1], follicles_grp)

        # creo el  bind final y joints en la superficie
        bind_jnts.append(
            mc.createNode("joint", n="{}bnd_jnt_{:02d}".format(prefix, x + 1)))

        mc.parent(bind_jnts[-1], fols_tr[-1], r=True)
        mc.setAttr(bind_jnts[-1] + ".radius", bnd_joints_rad)

    set_color(bind_jnts, "mid_blue")

    #creo un  temporal follicles para controles offset groups para alinear
    temp_fols = []
    temp_fols_tr = []

    for x in range(num_of_ctrls):

        temp_fols.append(mc.createNode("follicle"))
        temp_fols_tr.append(mc.listRelatives(temp_fols[-1], p=True)[0])

        mc.connectAttr(temp_fols[-1] + ".outTranslate",
                       temp_fols_tr[-1] + ".translate",
                       f=True)
        mc.connectAttr(temp_fols[-1] + ".outRotate",
                       temp_fols_tr[-1] + ".rotate",
                       f=True)

        mc.connectAttr(surf + ".worldMatrix[0]",
                       temp_fols[-1] + ".inputWorldMatrix")
        mc.connectAttr(surf + ".local", temp_fols[-1] + ".inputSurface")

    ####################################################

    if equal == 1:
        for x, temp_fol in enumerate(temp_fols):
            mc.setAttr(temp_fol + parameter, param_ctrls[x])
            mc.setAttr(temp_fol + other_param, 0.5)
    if equal == 0:
        v = 0
        for temp_fol in temp_fols:
            mc.setAttr(temp_fol + parameter, v)
            mc.setAttr(temp_fol + other_param, 0.5)
            v = v + (1.0 / divider_for_ctrls)

    ####################################################

    #creo controles y controle para joints
    controls = ctrl_maker(prefix,
                          ctrl_type="cube",
                          count=num_of_ctrls,
                          deg=3,
                          sp=8)

    ctrl_ofs_grps = []
    ctrl_joints = []
    ctrl_jnt_ofs_grps = []
    ctrl_joints_rad = bnd_joints_rad * 2
    ik_ctrl_scale = (length / 35) / (float(num_of_ctrls) / 5)

    for x, ctrl in enumerate(controls):

        ctrl_ofs_grp = mc.group(ctrl, n="{}_offset".format(ctrl))
        mc.delete(mc.parentConstraint(temp_fols_tr[x], ctrl_ofs_grp))
        ctrl_ofs_grps.append(ctrl_ofs_grp)

        #escala ik controls
        ctrl_shapes = mc.listRelatives(ctrl, s=True)
        for ctrl_shape in ctrl_shapes:
            ctrl_cvs_count = mc.getAttr(ctrl_shape + ".controlPoints",
                                        size=True)
            mc.scale(ik_ctrl_scale,
                     ik_ctrl_scale,
                     ik_ctrl_scale,
                     "{}.cv[0:{}]".format(ctrl_shape, ctrl_cvs_count - 1),
                     r=True,
                     ocp=True)

        #creo los controles de joints
        ctrl_joints.append(
            mc.createNode("joint", n="{}ctrl_jnt_{:02d}".format(prefix,
                                                                x + 1)))
        #seteo el radio de controles para joints de 2 tiepos. de el surface y joints
        mc.setAttr(ctrl_joints[x] + ".radius", ctrl_joints_rad)
        #creo offset groups para cotroles de joints
        ctrl_jnt_ofs_grp = mc.group(ctrl_joints[-1],
                                    n="{}_offset".format(ctrl_joints[-1]))
        mc.delete(mc.parentConstraint(temp_fols_tr[x], ctrl_jnt_ofs_grp))
        ctrl_jnt_ofs_grps.append(ctrl_jnt_ofs_grp)

    ###
    set_color(controls, "green")
    set_color(ctrl_joints, "red")

    mc.parent(ctrl_ofs_grps, ctrl_grp)
    mc.parent(ctrl_jnt_ofs_grps, ctrl_joints_grp)

    lock_hide(ctrl_ofs_grps, attrs[:9])
    lock_hide(ctrl_jnt_ofs_grps, attrs[:9])

    mc.delete(temp_fols_tr)

    ####################################################

    #determino que constraint o coneccion o metodo es elegido# que formalidad
    if constrain == 0:
        for (c, j) in izip(controls, ctrl_joints):
            for attr in attrs[:7]:  #skip de la escala de atributos
                mc.connectAttr(c + attr, j + attr)

        mc.parentConstraint(main_ctrl, ctrl_joints_grp, mo=True)
        mc.scaleConstraint(main_ctrl, ctrl_joints_grp)

        #escala del foliculo con el main // por coneccion del editor
        for flt in fols_tr:
            mc.connectAttr(main_ctrl + ".sx", flt + ".sx")
            mc.connectAttr(main_ctrl + ".sx", flt + ".sy")
            mc.connectAttr(main_ctrl + ".sx", flt + ".sz")

    elif constrain == 1:
        for (c, j) in izip(controls, ctrl_joints):
            mc.parentConstraint(c, j)
            mc.scaleConstraint(c, j)

        #scala del folliculos con el main control
        for flt in fols_tr:
            mc.scaleConstraint(main_ctrl, flt)

    #######################################################################

    if wire == True and num_of_ctrls > 1:

        temp_crv = mc.duplicateCurve(surf_tr + ".v[.5]",
                                     n=prefix + "wire_crv",
                                     local=False,
                                     ch=0)[0]

        if num_of_ctrls == 2:
            degree = 1
        else:
            degree = 3

        wire_crv = mc.curve(p=param_from_length(
            temp_crv, num_of_ctrls + (num_of_ctrls - 1), "open", "world"),
                            d=degree)

        mc.delete(temp_crv)

        wire_crv = mc.rename(
            wire_crv, prefix + "wire_crv"
        )  # Si el nombre va en el momento de la creacion, la forma no se renombra
        mc.delete(wire_crv, ch=True)
        wire = mc.wire(surf_tr,
                       gw=False,
                       en=1.0,
                       ce=0.0,
                       li=0.0,
                       dds=(0, 50),
                       w=wire_crv,
                       n=prefix + "wire")[0]
        mc.connectAttr(main_ctrl + ".sx", wire + ".scale[0]")

        cps = param_from_length(wire_crv,
                                num_of_ctrls,
                                "open",
                                "uv",
                                normalized=False)

        for cp in cps:
            mc.select("{}.u[{}]".format(wire_crv, cp), r=True)
            mc.dropoffLocator(1.0, 1.0, wire)

        mc.select(cl=True)

        for x, ctrl in enumerate(controls):
            mc.connectAttr(ctrl + ".rx",
                           "{}.wireLocatorTwist[{}]".format(wire, x))

        wire_grp = mc.group(wire_crv,
                            wire_crv + "BaseWire",
                            n=prefix + "wire_crv_grp")
        mc.parent(wire_grp, rig_grp)
        lock_hide([wire_grp], attrs[:9])

        wire_skin_cluster = mc.skinCluster(ctrl_joints,
                                           wire_crv,
                                           dr=2,
                                           mi=2,
                                           bm=0)[0]

    else:
        #bind de la superficie a los joints
        nurbs_skin_cluster = mc.skinCluster(ctrl_joints,
                                            surf_tr,
                                            dr=2,
                                            mi=num_of_ctrls - 1,
                                            ns=num_of_ctrls * 5,
                                            bm=0,
                                            n=prefix + "skinCluster")[0]
        mc.skinPercent(nurbs_skin_cluster, surf_tr, pruneWeights=0.2)

    if wire == True and num_of_ctrls == 1:
        mc.warning("wire skipped. at least 2 controls needed")

    ##########################################################################################

    mc.setAttr(surf_tr + ".v", 0)
    mc.setAttr(rig_grp + ".v", 0)

    mc.connectAttr(main_ctrl + ".sx", main_ctrl + ".sy")
    mc.connectAttr(main_ctrl + ".sx", main_ctrl + ".sz")
    mc.aliasAttr("Scale", main_ctrl + ".sx")

    set_color(main_ctrl, "yellow")

    mc.connectAttr(main_ctrl_offset + ".sx", main_ctrl_offset + ".sy")
    mc.connectAttr(main_ctrl_offset + ".sx", main_ctrl_offset + ".sz")
    mc.aliasAttr("Scale", main_ctrl_offset + ".sx")

    #lock and hide atributos
    lock_hide([
        final_group, follicles_grp, ctrl_joints_grp, surf_tr, ctrl_grp, rig_grp
    ], attrs[:9])
    lock_hide([ctrl_grp, main_ctrl, main_ctrl_offset], attrs[7:])
    lock_hide(controls, attrs[7:])

    #limpiamos seleccion (clear selection)
    mc.select(
        cl=True
    )  #Si la seleccion no se borra, se agrega un bind de control al conjunto de bind de enlace

    #crea a set con bind joints
    bind_jnts_set = mc.sets(n=prefix + "bind_jnts_set")
    mc.sets(bind_jnts, add=bind_jnts_set)

    mc.select(cl=True)

    ik_ctrls_set = mc.sets(n=prefix + "ik_ctrls_set")
    mc.sets(controls, add=ik_ctrls_set)

    mc.select(cl=True)

    controls_set = mc.sets(n=prefix + "controls_set")
    mc.sets(main_ctrl, ik_ctrls_set, add=controls_set)

    ##########################################################################################

    if add_fk == 1 and mc.getAttr(surf + ".formU") != 2 and mc.getAttr(
            surf + ".formV") != 2:

        fk_ctrls, fk_ctrl_off_grps = make_fk_ctrls(prefix, num_of_ctrls)
        mc.parent(fk_ctrl_off_grps[0], ctrl_grp)

        #scala fk controls
        fk_ctrl_scale = ik_ctrl_scale * 2

        for fk_ctrl in fk_ctrls:
            fk_ctrl_shapes = mc.listRelatives(fk_ctrl, s=True)
            for fk_ctrl_shape in fk_ctrl_shapes:
                fk_ctrl_cvs_count = mc.getAttr(fk_ctrl_shape +
                                               ".controlPoints",
                                               size=True)
                mc.scale(fk_ctrl_scale,
                         fk_ctrl_scale,
                         fk_ctrl_scale,
                         "{}.cv[0:{}]".format(fk_ctrl_shape,
                                              fk_ctrl_cvs_count - 1),
                         r=True,
                         ocp=True)

        #add fk controls al set
        mc.select(cl=True)
        fk_ctrls_set = mc.sets(n=prefix + "fk_ctrls_set")
        mc.sets(fk_ctrls, add=fk_ctrls_set)

        ########
        ik_ctrl_constr_grps = [
            mc.group(ctrl, n=ctrl + "_constr_grp") for ctrl in controls
        ]
        [
            mc.xform(ik_ctrl_constr_grp, piv=(0, 0, 0), os=True)
            for ik_ctrl_constr_grp in ik_ctrl_constr_grps
        ]

        for ik, fk in izip(controls[:-1], fk_ctrl_off_grps):
            mc.delete(mc.parentConstraint(ik, fk))

        for fk, ik in izip(fk_ctrls, ik_ctrl_constr_grps[:-1]):
            mc.parentConstraint(fk, ik)

        #constrain ultimo ik ctrl
        mc.parentConstraint(fk_ctrls[-1], ik_ctrl_constr_grps[-1], mo=True)
        lock_hide(ik_ctrl_constr_grps, attrs[:9])

        ########
        set_color(fk_ctrls, "blue")
        lock_hide(fk_ctrl_off_grps, attrs[:9])

        mc.sets(fk_ctrls_set, add=controls_set)

        mc.select(cl=True)

    elif add_fk == 1 and (mc.getAttr(surf + ".formU") == 2
                          or mc.getAttr(surf + ".formV") == 2):

        mc.warning("surface is periodic. fk controls skipped")

    ################ ADD mensaje de atributo ################

    mc.addAttr(main_ctrl, ln="joints", at="message")
    mc.addAttr(main_ctrl, ln="follicles", at="message")
    mc.addAttr(main_ctrl, ln="surface", at="message")

    if mc.attributeQuery("i_am_the_surface", node=surf, exists=True) == False:
        mc.addAttr(surf, ln="i_am_the_surface", at="message")

    mc.connectAttr(main_ctrl + ".surface", surf + ".i_am_the_surface")

    for j, f in izip(bind_jnts, fols):
        mc.addAttr(j, ln="i_am_a_joint", at="message")
        mc.addAttr(f, ln="i_am_a_follicle", at="message")
        mc.connectAttr(main_ctrl + ".joints", j + ".i_am_a_joint")
        mc.connectAttr(main_ctrl + ".follicles", f + ".i_am_a_follicle")
Ejemplo n.º 10
0
    def rebuild(self):
        '''
		Rebuild the wire deformer from the recorded deformerData
		'''
        # Rebuild deformer
        wire = super(WireData, self).rebuild()

        # Check Wire Curves
        for curve in self.influenceData.iterkeys():
            if not mc.objExists(curve):
                pts = self.influenceData[curve]['cvList']
                knots = self.influenceData[curve]['knots']
                degree = self.influenceData[curve]['degree']
                mc.curve(p=pts, k=knots, d=degree, n=curve)

        # Check Base Curves
        for curve in self.influenceBaseData.iterkeys():
            if not mc.objExists(curve):
                pts = self.influenceBaseData[curve]['cvList']
                knots = self.influenceBaseData[curve]['knots']
                degree = self.influenceBaseData[curve]['degree']
                curve = mc.curve(p=pts, k=knots, d=degree, n=curve)
                mc.setAttr(curve + '.v', 0)

        # Check Dropoff Locators
        for locator in self.dropoffLocatorData.iterkeys():
            if mc.objExists(self.dropoffLocatorData[locator]['parent']):
                mc.delete(self.dropoffLocatorData[locator]['parent'])

        # Set Deformer Attributes
        mc.setAttr(wire + '.crossingEffect', self.crossingEffect)
        mc.setAttr(wire + '.tension', self.tension)
        mc.setAttr(wire + '.localInfluence', self.localInfluence)
        mc.setAttr(wire + '.rotation', self.rotation)

        # Connect wire curves
        for curve in self.influenceData.iterkeys():
            mc.connectAttr(curve + '.worldSpace[0]',
                           wire + '.deformedWire[' +
                           str(self.influenceData[curve]['index']) + ']',
                           f=True)
        # Connect base curves
        for curve in self.influenceBaseData.iterkeys():
            mc.connectAttr(curve + '.worldSpace[0]',
                           wire + '.baseWire[' +
                           str(self.influenceBaseData[curve]['index']) + ']',
                           f=True)

        # Set Influence Attributes
        for influence in self.influenceData.iterkeys():
            infIndex = self.influenceData[influence]['index']
            mc.setAttr(wire + '.dropoffDistance[' + str(infIndex) + ']',
                       self.influenceData[influence]['dropoff'])
            mc.setAttr(wire + '.scale[' + str(infIndex) + ']',
                       self.influenceData[influence]['scale'])

        # Recreate Dropoff Locators
        for locator in self.dropoffLocatorData.iterkeys():
            locIndex = self.dropoffLocatorData[locator]['index']
            param = self.dropoffLocatorData[locator]['parameter']
            parent = self.dropoffLocatorData[locator]['parent']
            env = self.dropoffLocatorData[locator]['envelope']
            percent = self.dropoffLocatorData[locator]['percent']
            mc.select(parent + '.u[' + str(param) + ']')
            newLoc = mc.dropoffLocator(env, percent, wire)
            mc.setAttr(wire + '.wireLocatorTwist[' + str(locIndex) + ']',
                       self.dropoffLocatorData[locator]['twist'])
            if parent != newLoc: newLoc = mc.rename(newLoc, parent)
            locShape = mc.listRelatives(newLoc, s=True, ni=True)[0]
            if locator != locShape: locator = mc.rename(locShape, locator)

        # Return result
        return wire
Ejemplo n.º 11
0
	def rebuild(self):
		'''
		Rebuild the wire deformer from the recorded deformerData
		'''
		# Rebuild deformer
		wire = super(WireData, self).rebuild()
		
		# Check Wire Curves
		for curve in self.influenceData.iterkeys():
			if not mc.objExists(curve):
				pts = self.influenceData[curve]['cvList']
				knots = self.influenceData[curve]['knots']
				degree = self.influenceData[curve]['degree']
				mc.curve(p=pts,k=knots,d=degree,n=curve)
		
		# Check Base Curves
		for curve in self.influenceBaseData.iterkeys():
			if not mc.objExists(curve):
				pts = self.influenceBaseData[curve]['cvList']
				knots = self.influenceBaseData[curve]['knots']
				degree = self.influenceBaseData[curve]['degree']
				curve = mc.curve(p=pts,k=knots,d=degree,n=curve)
				mc.setAttr(curve+'.v',0)
		
		# Check Dropoff Locators
		for locator in self.dropoffLocatorData.iterkeys():
			if mc.objExists(self.dropoffLocatorData[locator]['parent']):
				mc.delete(self.dropoffLocatorData[locator]['parent'])
		
		# Set Deformer Attributes
		mc.setAttr(wire+'.crossingEffect',self.crossingEffect)
		mc.setAttr(wire+'.tension',self.tension)
		mc.setAttr(wire+'.localInfluence',self.localInfluence)
		mc.setAttr(wire+'.rotation',self.rotation)
		
		# Connect wire curves
		for curve in self.influenceData.iterkeys():
			mc.connectAttr(curve+'.worldSpace[0]',wire+'.deformedWire['+str(self.influenceData[curve]['index'])+']',f=True)
		# Connect base curves
		for curve in self.influenceBaseData.iterkeys():
			mc.connectAttr(curve+'.worldSpace[0]',wire+'.baseWire['+str(self.influenceBaseData[curve]['index'])+']',f=True)
		
		# Set Influence Attributes
		for influence in self.influenceData.iterkeys():
			infIndex = self.influenceData[influence]['index']
			mc.setAttr(wire+'.dropoffDistance['+str(infIndex)+']',self.influenceData[influence]['dropoff'])
			mc.setAttr(wire+'.scale['+str(infIndex)+']',self.influenceData[influence]['scale'])
		
		# Recreate Dropoff Locators
		for locator in self.dropoffLocatorData.iterkeys():
			locIndex = self.dropoffLocatorData[locator]['index']
			param = self.dropoffLocatorData[locator]['parameter']
			parent = self.dropoffLocatorData[locator]['parent']
			env = self.dropoffLocatorData[locator]['envelope']
			percent = self.dropoffLocatorData[locator]['percent']
			mc.select(parent+'.u['+str(param)+']')
			newLoc = mc.dropoffLocator(env,percent,wire)
			mc.setAttr(wire+'.wireLocatorTwist['+str(locIndex)+']',self.dropoffLocatorData[locator]['twist'])
			if parent != newLoc: newLoc = mc.rename(newLoc,parent)
			locShape = mc.listRelatives(newLoc,s=True,ni=True)[0]
			if locator != locShape: locator = mc.rename(locShape,locator)
		
		# Return result
		return wire
Ejemplo n.º 12
0
def ribbonize(surf_tr,
              equal=1,
              num_of_ctrls=5,
              num_of_jnts=29,
              prefix="",
              constrain=1,
              add_fk=0,
              wire=0):

    attrs = [
        ".tx", ".ty", ".tz", ".rx", ".ry", ".rz", ".sx", ".sy", ".sz", ".v"
    ]

    if prefix == "":
        mc.warning("care to name it?")
        return

    else:
        prefix = prefix + "_"

    #####################################################

    surf_tr = mc.rename(surf_tr, prefix + "ribbon_surface")
    surf = mc.listRelatives(surf_tr, shapes=True)[0]

    # freeze transformations and delete the surface history
    mc.makeIdentity(surf_tr, t=True, r=True, s=True, apply=True)
    mc.delete(surf_tr, ch=True)

    # duplicate surface curves to determine the direction
    u_curve = mc.duplicateCurve(surf_tr + ".v[.5]", local=True, ch=0)
    v_curve = mc.duplicateCurve(surf_tr + ".u[.5]", local=True, ch=0)

    # delete the history just in case
    mc.delete(surf_tr, ch=True)

    u_length = mc.arclen(u_curve)
    v_length = mc.arclen(v_curve)

    if u_length < v_length:
        mc.reverseSurface(surf_tr, d=3, ch=False, rpo=True)
        mc.reverseSurface(surf_tr, d=0, ch=False, rpo=True)

    parameter = ".parameterU"
    other_param = ".parameterV"

    # correct u_curve after reversing to calculate the length
    u_curve_corr = mc.duplicateCurve(surf_tr + ".v[.5]", local=True, ch=0)[0]

    #############################################################################

    # selected surface is periodic or open? (cylinder or a plane)
    if mc.getAttr(surf + ".formU") == 2 or mc.getAttr(surf + ".formV") == 2:
        curve_type = "periodic"
        divider_for_ctrls = num_of_ctrls
    elif mc.getAttr(surf + ".formU") == 0 or mc.getAttr(surf + ".formV") == 0:
        curve_type = "open"
        divider_for_ctrls = num_of_ctrls - 1

    #############################################################################
    param_ctrls = param_from_length(u_curve_corr, num_of_ctrls, curve_type,
                                    "uv")
    param_joints = param_from_length(u_curve_corr, num_of_jnts, curve_type,
                                     "uv")

    length = mc.arclen(u_curve_corr)
    mc.delete(u_curve, v_curve, u_curve_corr)

    ############################################################################

    # create groups, main control and main control offset
    final_group = mc.group(n=prefix + "ribbon_grp", em=True)
    ctrl_joints_grp = mc.group(n=prefix + "ctrl_joints_grp", em=True)
    ctrl_grp = mc.group(n=prefix + "ctrls_grp", em=True)
    follicles_grp = mc.group(n=prefix + "follicles_grp", em=True)
    rig_grp = mc.group(n=prefix + "rig_grp", em=True)
    main_ctrl = mc.circle(n=prefix + "ctrl_main",
                          nr=(0, 1, 0),
                          r=length / 5,
                          ch=0)[0]
    main_ctrl_offset = mc.group(n=prefix + "ctrl_main_offset", em=True)

    mc.parent(main_ctrl, main_ctrl_offset)
    mc.parent(ctrl_grp, main_ctrl)
    mc.parent(main_ctrl_offset, rig_grp, final_group)
    mc.parent(surf_tr, ctrl_joints_grp, follicles_grp, rig_grp)

    # move main_ctrl_offset to the center of the surfaces bbox (in case its pivot is somewhere else)
    mid_point = get_bbox_center(surf_tr)
    for attr, mid_pnt_el in izip(attrs[:3], mid_point):
        mc.setAttr(main_ctrl_offset + attr, mid_pnt_el)

    ############################################################################

    fols = []
    fols_tr = []
    bind_jnts = []
    bnd_joints_rad = (length / 60) / (float(num_of_jnts) / 40)

    for x in range(num_of_jnts):

        fol = mc.createNode("follicle")
        mc.setAttr(fol + ".visibility", 0)
        temp_fol = mc.listRelatives(fol, p=True)[0]
        fols_tr.append(
            mc.rename(temp_fol, "{}follicle_{:02d}".format(prefix, x + 1)))
        fols.append(mc.listRelatives(fols_tr[-1], s=True)[0])

        # connect follicle shapes to their transforms
        mc.connectAttr(fols[-1] + ".outTranslate",
                       fols_tr[-1] + ".translate",
                       f=True)
        mc.connectAttr(fols[-1] + ".outRotate",
                       fols_tr[-1] + ".rotate",
                       f=True)

        # attach follicle shapes to the surface
        mc.connectAttr(surf + ".worldMatrix[0]",
                       fols[-1] + ".inputWorldMatrix")
        mc.connectAttr(surf + ".local", fols[-1] + ".inputSurface")

        mc.setAttr(fols[-1] + parameter, param_joints[x])
        mc.setAttr(fols[-1] + other_param, 0.5)

        mc.parent(fols_tr[-1], follicles_grp)

        # create final bind joints on the surface
        bind_jnts.append(
            mc.createNode("joint", n="{}bnd_jnt_{:02d}".format(prefix, x + 1)))

        mc.parent(bind_jnts[-1], fols_tr[-1], r=True)
        mc.setAttr(bind_jnts[-1] + ".radius", bnd_joints_rad)

    set_color(bind_jnts, "mid_blue")

    #create temp follicles for control offset groups to align
    temp_fols = []
    temp_fols_tr = []

    for x in range(num_of_ctrls):

        temp_fols.append(mc.createNode("follicle"))
        temp_fols_tr.append(mc.listRelatives(temp_fols[-1], p=True)[0])

        mc.connectAttr(temp_fols[-1] + ".outTranslate",
                       temp_fols_tr[-1] + ".translate",
                       f=True)
        mc.connectAttr(temp_fols[-1] + ".outRotate",
                       temp_fols_tr[-1] + ".rotate",
                       f=True)

        mc.connectAttr(surf + ".worldMatrix[0]",
                       temp_fols[-1] + ".inputWorldMatrix")
        mc.connectAttr(surf + ".local", temp_fols[-1] + ".inputSurface")

    ####################################################

    if equal == 1:
        for x, temp_fol in enumerate(temp_fols):
            mc.setAttr(temp_fol + parameter, param_ctrls[x])
            mc.setAttr(temp_fol + other_param, 0.5)
    if equal == 0:
        v = 0
        for temp_fol in temp_fols:
            mc.setAttr(temp_fol + parameter, v)
            mc.setAttr(temp_fol + other_param, 0.5)
            v = v + (1.0 / divider_for_ctrls)

    ####################################################

    #create controls and control joints
    controls = ctrl_maker(prefix,
                          ctrl_type="cube",
                          count=num_of_ctrls,
                          deg=3,
                          sp=8)

    ctrl_ofs_grps = []
    ctrl_joints = []
    ctrl_jnt_ofs_grps = []
    ctrl_joints_rad = bnd_joints_rad * 2
    ik_ctrl_scale = (length / 35) / (float(num_of_ctrls) / 5)

    for x, ctrl in enumerate(controls):

        ctrl_ofs_grp = mc.group(ctrl, n="{}_offset".format(ctrl))
        mc.delete(mc.parentConstraint(temp_fols_tr[x], ctrl_ofs_grp))
        ctrl_ofs_grps.append(ctrl_ofs_grp)

        #scale ik controls
        ctrl_shapes = mc.listRelatives(ctrl, s=True)
        for ctrl_shape in ctrl_shapes:
            ctrl_cvs_count = mc.getAttr(ctrl_shape + ".controlPoints",
                                        size=True)
            mc.scale(ik_ctrl_scale,
                     ik_ctrl_scale,
                     ik_ctrl_scale,
                     "{}.cv[0:{}]".format(ctrl_shape, ctrl_cvs_count - 1),
                     r=True,
                     ocp=True)

        #create the control joints
        ctrl_joints.append(
            mc.createNode("joint", n="{}ctrl_jnt_{:02d}".format(prefix,
                                                                x + 1)))
        #set the radius of controls joints to 2 times that of the surface joints
        mc.setAttr(ctrl_joints[x] + ".radius", ctrl_joints_rad)
        #create offset groups for ctrl joints
        ctrl_jnt_ofs_grp = mc.group(ctrl_joints[-1],
                                    n="{}_offset".format(ctrl_joints[-1]))
        mc.delete(mc.parentConstraint(temp_fols_tr[x], ctrl_jnt_ofs_grp))
        ctrl_jnt_ofs_grps.append(ctrl_jnt_ofs_grp)

    ###
    set_color(controls, "green")
    set_color(ctrl_joints, "red")

    mc.parent(ctrl_ofs_grps, ctrl_grp)
    mc.parent(ctrl_jnt_ofs_grps, ctrl_joints_grp)

    lock_hide(ctrl_ofs_grps, attrs[:9])
    lock_hide(ctrl_jnt_ofs_grps, attrs[:9])

    mc.delete(temp_fols_tr)

    ####################################################

    #determine if constraint or connection method is chosen
    if constrain == 0:
        for (c, j) in izip(controls, ctrl_joints):
            for attr in attrs[:7]:  #skip scale attributes
                mc.connectAttr(c + attr, j + attr)

        mc.parentConstraint(main_ctrl, ctrl_joints_grp, mo=True)
        mc.scaleConstraint(main_ctrl, ctrl_joints_grp)

        #scale the follicles with the main control
        for flt in fols_tr:
            mc.connectAttr(main_ctrl + ".sx", flt + ".sx")
            mc.connectAttr(main_ctrl + ".sx", flt + ".sy")
            mc.connectAttr(main_ctrl + ".sx", flt + ".sz")

    elif constrain == 1:
        for (c, j) in izip(controls, ctrl_joints):
            mc.parentConstraint(c, j)
            mc.scaleConstraint(c, j)

        #scale the follicles with the main control
        for flt in fols_tr:
            mc.scaleConstraint(main_ctrl, flt)

    #######################################################################

    if wire == True and num_of_ctrls > 1:

        temp_crv = mc.duplicateCurve(surf_tr + ".v[.5]",
                                     n=prefix + "wire_crv",
                                     local=False,
                                     ch=0)[0]

        if num_of_ctrls == 2:
            degree = 1
        else:
            degree = 3

        wire_crv = mc.curve(p=param_from_length(
            temp_crv, num_of_ctrls + (num_of_ctrls - 1), "open", "world"),
                            d=degree)

        mc.delete(temp_crv)

        wire_crv = mc.rename(
            wire_crv, prefix + "wire_crv"
        )  # if name at the creation time, the shape doesn't get renamed
        mc.delete(wire_crv, ch=True)
        wire = mc.wire(surf_tr,
                       gw=False,
                       en=1.0,
                       ce=0.0,
                       li=0.0,
                       dds=(0, 50),
                       w=wire_crv,
                       n=prefix + "wire")[0]
        mc.connectAttr(main_ctrl + ".sx", wire + ".scale[0]")

        cps = param_from_length(wire_crv,
                                num_of_ctrls,
                                "open",
                                "uv",
                                normalized=False)

        for cp in cps:
            mc.select("{}.u[{}]".format(wire_crv, cp), r=True)
            mc.dropoffLocator(1.0, 1.0, wire)

        mc.select(cl=True)

        for x, ctrl in enumerate(controls):
            mc.connectAttr(ctrl + ".rx",
                           "{}.wireLocatorTwist[{}]".format(wire, x))

        wire_grp = mc.group(wire_crv,
                            wire_crv + "BaseWire",
                            n=prefix + "wire_crv_grp")
        mc.parent(wire_grp, rig_grp)
        lock_hide([wire_grp], attrs[:9])

        wire_skin_cluster = mc.skinCluster(ctrl_joints,
                                           wire_crv,
                                           dr=2,
                                           mi=2,
                                           bm=0)[0]

    else:
        #bind the surface to the joints
        nurbs_skin_cluster = mc.skinCluster(ctrl_joints,
                                            surf_tr,
                                            dr=2,
                                            mi=num_of_ctrls - 1,
                                            ns=num_of_ctrls * 5,
                                            bm=0,
                                            n=prefix + "skinCluster")[0]
        mc.skinPercent(nurbs_skin_cluster, surf_tr, pruneWeights=0.2)

    if wire == True and num_of_ctrls == 1:
        mc.warning("wire skipped. at least 2 controls needed")

    ##########################################################################################

    mc.setAttr(surf_tr + ".v", 0)
    mc.setAttr(rig_grp + ".v", 0)

    mc.connectAttr(main_ctrl + ".sx", main_ctrl + ".sy")
    mc.connectAttr(main_ctrl + ".sx", main_ctrl + ".sz")
    mc.aliasAttr("Scale", main_ctrl + ".sx")

    set_color(main_ctrl, "yellow")

    mc.connectAttr(main_ctrl_offset + ".sx", main_ctrl_offset + ".sy")
    mc.connectAttr(main_ctrl_offset + ".sx", main_ctrl_offset + ".sz")
    mc.aliasAttr("Scale", main_ctrl_offset + ".sx")

    #lock and hide attributes
    lock_hide([
        final_group, follicles_grp, ctrl_joints_grp, surf_tr, ctrl_grp, rig_grp
    ], attrs[:9])
    lock_hide([ctrl_grp, main_ctrl, main_ctrl_offset], attrs[7:])
    lock_hide(controls, attrs[7:])

    #clear selection
    mc.select(
        cl=True
    )  #if selection isn't cleared a control joint gets added to the bind joints set

    #create a set with bind joints
    bind_jnts_set = mc.sets(n=prefix + "bind_jnts_set")
    mc.sets(bind_jnts, add=bind_jnts_set)

    mc.select(cl=True)

    ik_ctrls_set = mc.sets(n=prefix + "ik_ctrls_set")
    mc.sets(controls, add=ik_ctrls_set)

    mc.select(cl=True)

    controls_set = mc.sets(n=prefix + "controls_set")
    mc.sets(main_ctrl, ik_ctrls_set, add=controls_set)

    ##########################################################################################

    if add_fk == 1 and mc.getAttr(surf + ".formU") != 2 and mc.getAttr(
            surf + ".formV") != 2:

        fk_ctrls, fk_ctrl_off_grps = make_fk_ctrls(prefix, num_of_ctrls)
        mc.parent(fk_ctrl_off_grps[0], ctrl_grp)

        #scale fk controls
        fk_ctrl_scale = ik_ctrl_scale * 2

        for fk_ctrl in fk_ctrls:
            fk_ctrl_shapes = mc.listRelatives(fk_ctrl, s=True)
            for fk_ctrl_shape in fk_ctrl_shapes:
                fk_ctrl_cvs_count = mc.getAttr(fk_ctrl_shape +
                                               ".controlPoints",
                                               size=True)
                mc.scale(fk_ctrl_scale,
                         fk_ctrl_scale,
                         fk_ctrl_scale,
                         "{}.cv[0:{}]".format(fk_ctrl_shape,
                                              fk_ctrl_cvs_count - 1),
                         r=True,
                         ocp=True)

        #add fk controls to a set
        mc.select(cl=True)
        fk_ctrls_set = mc.sets(n=prefix + "fk_ctrls_set")
        mc.sets(fk_ctrls, add=fk_ctrls_set)

        ########
        ik_ctrl_constr_grps = [
            mc.group(ctrl, n=ctrl + "_constr_grp") for ctrl in controls
        ]
        [
            mc.xform(ik_ctrl_constr_grp, piv=(0, 0, 0), os=True)
            for ik_ctrl_constr_grp in ik_ctrl_constr_grps
        ]

        for ik, fk in izip(controls[:-1], fk_ctrl_off_grps):
            mc.delete(mc.parentConstraint(ik, fk))

        for fk, ik in izip(fk_ctrls, ik_ctrl_constr_grps[:-1]):
            mc.parentConstraint(fk, ik)

        #constrain last ik ctrl
        mc.parentConstraint(fk_ctrls[-1], ik_ctrl_constr_grps[-1], mo=True)
        lock_hide(ik_ctrl_constr_grps, attrs[:9])

        ########
        set_color(fk_ctrls, "blue")
        lock_hide(fk_ctrl_off_grps, attrs[:9])

        mc.sets(fk_ctrls_set, add=controls_set)

        mc.select(cl=True)

    elif add_fk == 1 and (mc.getAttr(surf + ".formU") == 2
                          or mc.getAttr(surf + ".formV") == 2):

        mc.warning("surface is periodic. fk controls skipped")

    ################ADD MESSAGE ATTRS################

    mc.addAttr(main_ctrl, ln="joints", at="message")
    mc.addAttr(main_ctrl, ln="follicles", at="message")
    mc.addAttr(main_ctrl, ln="surface", at="message")

    if mc.attributeQuery("i_am_the_surface", node=surf, exists=True) == False:
        mc.addAttr(surf, ln="i_am_the_surface", at="message")

    mc.connectAttr(main_ctrl + ".surface", surf + ".i_am_the_surface")

    for j, f in izip(bind_jnts, fols):
        mc.addAttr(j, ln="i_am_a_joint", at="message")
        mc.addAttr(f, ln="i_am_a_follicle", at="message")
        mc.connectAttr(main_ctrl + ".joints", j + ".i_am_a_joint")
        mc.connectAttr(main_ctrl + ".follicles", f + ".i_am_a_follicle")