Exemple #1
0
 def zeroOut_cmd(self):
     z = zeroOut()
     hireSel = []
     sel = cmds.ls(sl=True)
     for i in sel:
         #del hireSel[0:len(hireSel)]
         cmds.select("%s" % i, hierarchy=True, add=True)
         ee = cmds.ls(sl=1)
         for j in ee:
             z.zeroOutJoint(j)
Exemple #2
0
    def __init__(self):

        self.disDMS = list()
        self.IKcurveAttatchLOC = list()
        self.IKcurveAttatchNUL = list()
        self.IKSubCon = list()
        self.IKSubNull = list()
        self.FKCon = list()
        self.FKNull = list()
        self.defaultGrp = defaultGroupNode()
        self.z = zeroOut()
        self.worldCON = ['place_CON','direction_CON','move_CON','root_CON']
        self.trs = ['t','r','s']
        self.xyz = ['x','y','z']
        self.XYZ = ['X','Y','Z']
Exemple #3
0
    def set(self):

        list = cmds.ls('*Blend*JNT*', typ='joint')

        skinJoints = []

        for e in list:
            if cmds.objExists(e.replace('Blend', 'Skin')) is not True:

                tmp = cmds.createNode('joint', n=e.replace('Blend', 'Skin'))
                cmds.delete(cmds.parentConstraint(e, tmp, w=True))
                z = zeroOut()
                z.zeroOutJoint(tmp)
                cmds.parentConstraint(e, tmp, w=True)
                cmds.parent(tmp, 'SkinJoint_GRP')
                skinJoints.append(tmp)
            else:
                continue

        return skinJoints
Exemple #4
0
    def similarPose(self, jnt):

        tmp = []
        parents = []

        #called zeroOut class
        zero = zeroOut()

        if 'L_' in jnt:
            tmp = cmds.joint(jnt, n='replace_' + jnt)
            cmds.parent(tmp, w=1)
            cmds.mirrorJoint(tmp,
                             mirrorYZ=True,
                             mirrorBehavior=True,
                             searchReplace=('L_', 'R_'))
            ls = cmds.listRelatives(jnt.replace('L_', 'R_'), c=True)
            if ls is not None:
                cmds.parent(ls, w=True)
                cmds.delete(
                    cmds.parentConstraint(tmp.replace('L_', 'R_'),
                                          jnt.replace('L_', 'R_'),
                                          w=1))
                cmds.parent(ls, jnt.replace('L_', 'R_'))
                cmds.delete(tmp, tmp.replace('L_', 'R_'))
                zero.zeroOutJoint(jnt)
                zero.zeroOutJoint(jnt.replace('L_', 'R_'))
            else:
                cmds.delete(
                    cmds.parentConstraint(tmp.replace('L_', 'R_'),
                                          jnt.replace('L_', 'R_'),
                                          w=1))
                cmds.delete(tmp, tmp.replace('L_', 'R_'))
                zero.zeroOutJoint(jnt)
                zero.zeroOutJoint(jnt.replace('L_', 'R_'))

        else:

            zero.zeroOutJoint(jnt)

        return
Exemple #5
0
    def blendTwist(self, base, start, end, num):

        name = ''
        twist = []
        twistNul = []
        joints = []

        if '_' in start:
            lst = start.split('_')
            for e in lst[:-1]:
                if len(name) != 0:
                    name = name + '_' + e
                else:
                    name = name + e
            name = name
        else:
            name = start

        tmp = cmds.spaceLocator(n=name + 'Up')
        rotUpVec = setUniqueName(tmp[0], 'LOC')
        rotUpNul = homeNul(rotUpVec)
        cmds.parentConstraint(end, rotUpNul, w=True)

        v = cmds.getAttr(end + '.tx')

        #레프트 라이트에따라서 에임되는 수치가 다르다.
        #레프트는 -1 0 0
        #라이트는 1 0 0 이다.

        cmds.aimConstraint(start,
                           rotUpVec,
                           w=True,
                           aim=[v / (abs(v)) * -1, 0, 0],
                           u=[0, 1, 0],
                           wut='none')

        #지정된 갯수만큼 블랜드 로케이터를 생성 한다.
        for i in range(num):
            tmp = cmds.spaceLocator(n=name + 'Twist')
            twist.append(setUniqueName(tmp[0], 'LOC'))
            twistNul.append(homeNul(twist[i]))

        tmp = cmds.group(twistNul, n=name + 'TwistAim')
        twistAim = setUniqueName(tmp, 'NUL')

        tmp = cmds.group(twistAim, n=name + 'TwistGroup')
        twistGrp = setUniqueName(tmp, 'NUL')

        cmds.delete(cmds.parentConstraint(start, twistGrp, w=True))
        cmds.parentConstraint(base, twistGrp, mo=True)
        cmds.aimConstraint(end,
                           twistAim,
                           w=True,
                           aim=[v / (abs(v)), 0, 0],
                           u=[0, 1, 0],
                           wut='none')
        cmds.pointConstraint(start, twistAim, w=True)

        #페어블랜드 노드를 이용하여
        #조인트의 늘어난 거리만큼 블랜드 로케이터들을 위치 시킨다.
        for i in range(num):
            pbd = cmds.createNode('pairBlend')
            cmds.connectAttr(end + '.t', pbd + '.inTranslate2', f=True)
            cmds.connectAttr(pbd + '.outTranslateX',
                             twistNul[i] + '.tx',
                             f=True)
            if i is 0:
                cmds.setAttr(pbd + '.weight', 0.01)
            else:
                cmds.setAttr(pbd + '.weight', (0.99 / (num - 1)) * i)

        cmds.aimConstraint(start,
                           twist[-1],
                           w=True,
                           aim=[v / (abs(v)) * -1, 0, 0],
                           u=[0, 1, 0],
                           wut='objectrotation',
                           wuo=rotUpVec)

        #페어블랜드로 로케이터들의 트위스트값을
        #나눈다.
        for i in range(num - 1):
            pbd = cmds.createNode('pairBlend')
            cmds.connectAttr(twist[-1] + '.r', pbd + '.inRotate2', f=True)
            cmds.connectAttr(pbd + '.outRotate', twist[i] + '.r', f=True)
            cmds.setAttr(pbd + '.weight', (1.0 / (num - 1)) * i)
            cmds.setAttr(pbd + '.rotInterpolation', 1)

        #트위스트 블랜드 조인트를 생성 하여
        #트위스트 로케이터와 컨스트레인 한다.
        z = zeroOut()
        for e in twist:
            tmp = cmds.createNode('joint', n=e.replace('_LOC', ''))
            jnt = setUniqueName(tmp, 'JNT')
            cmds.delete(cmds.parentConstraint(e, jnt, w=True))
            z.zeroOutJoint(jnt)
            cmds.parentConstraint(e, jnt, w=True)
            cmds.parent(jnt, 'BlendJoint_GRP')
            joints.append(jnt)

        cmds.parent(rotUpNul, twistGrp)
        cmds.parent(twistGrp, 'twist_GRP')

        return joints