def createReverseFoot(self):
# create foot temple
pivotPos = cmds.xform(self.IkForeLegJointList[-2],
t=True,
ws=True,
q=True)
FTT = cmds.spaceLocator(n=self.footTemplateLocList[4])
cmds.move(pivotPos[0], pivotPos[1], pivotPos[2], FTT[0])
BRT = cmds.spaceLocator(n=self.footTemplateLocList[5])
POsnap(BRT[0], self.IkForeLegJointList[-2])
TTT = cmds.spaceLocator(n=self.footTemplateLocList[6])
POsnap(TTT[0], self.IkForeLegJointList[-2])
# create pivot positon
for x in range(len(self.footTemplateLocList)):
PL = cmds.group(em=True,
n=self.footTemplateLocList[x].replace(
'Temple', '_PIVOT'))
POsnap(PL, self.footTemplateLocList[x])
self.pivotList.append(PL)
for x in range(len(self.pivotList) - 1):
cmds.parent(self.pivotList[x + 1], self.pivotList[x])
for x in range(len(self.pivotList)):
PH = homeNul(self.pivotList[x])
self.pivotNulList.append(PH)
cmds.parent(self.pivotNulList[-1], self.pivotList[4])
cmds.delete(self.footTemplateLocList[4:7])
# parenting handle
cmds.parent(self.G_RPName, self.pivotList[5])
cmds.parent(self.SCs1Name, self.G_RPName)
cmds.parent(self.SCs2Name, self.pivotList[5])
cmds.parent(self.SCs3Name, self.pivotList[-1])
self.wristPivotName = cmds.group(em=True, n='L_wistRoll_PIVOT')
self.wristPos = cmds.xform(self.IkForeLegJointList[3],
t=True,
ws=True,
q=True)
cmds.move(self.wristPos[0], self.wristPos[1], self.wristPos[2],
self.wristPivotName)
cmds.parent(self.wristPivotName, self.subIkJointList[2])
cmds.parent(self.RPsName, self.wristPivotName)
homeNul(self.wristPivotName)
def createReverseFoot(self):
# create foot temple
pivotPos = cmds.xform( self.IkHindLegJointList[-2], t=True, ws=True, q=True )
FTT = cmds.spaceLocator( n=self.footTemplateLocList[4] )
cmds.move( pivotPos[0], pivotPos[1], pivotPos[2], FTT[0] )
BRT = cmds.spaceLocator( n=self.footTemplateLocList[5] )
POsnap( BRT[0], self.IkHindLegJointList[-2] )
TTT = cmds.spaceLocator( n=self.footTemplateLocList[6] )
POsnap( TTT[0], self.IkHindLegJointList[-2] )
# create pivot positon
for x in range( len( self.footTemplateLocList ) ):
PL = cmds.group( em=True, n=self.footTemplateLocList[x].replace( 'Temple', '_PIVOT' ) )
POsnap( PL, self.footTemplateLocList[x] )
self.pivotList.append(PL)
for x in range( len( self.pivotList ) - 1 ):
cmds.parent( self.pivotList[x+1], self.pivotList[x] )
for x in range( len( self.pivotList ) ):
PH = homeNul( self.pivotList[x] )
self.pivotNulList.append(PH)
cmds.parent( self.pivotNulList[-1], self.pivotList[4] )
cmds.delete( self.footTemplateLocList[4:7] )
# parenting handle
cmds.parent( self.sRPsName, self.pivotList[5] )
cmds.parent( self.SCsNameList[0], self.sRPsName )
cmds.parent( self.SCsNameList[1], self.pivotList[5] )
cmds.parent( self.SCsNameList[2], self.pivotList[-1] )
self.anklePivotName = cmds.group( em=True, n='%s_ankleRoll_PIVOT' % self.side )
self.anklePos = cmds.xform( self.IkHindLegJointList[3], t=True, ws=True, q=True )
cmds.move( self.anklePos[0], self.anklePos[1], self.anklePos[2], self.anklePivotName )
cmds.delete( cmds.aimConstraint( self.subIkJointList[2], self.anklePivotName, aimVector=[ 0, 1, 0 ], upVector=[ 0, 0, 1 ], worldUpType='vector', worldUpVector=[ 0, 1, 0 ] ) )
cmds.parent( self.anklePivotName, self.subIkJointList[2] )
cmds.parent( self.RPsName, self.anklePivotName )
homeNul( self.anklePivotName )
def setup(self, base, target, con):
name = ''
if '_' in con:
lst = con.split('_')
for e in lst[:-1]:
if len(name) != 0:
name = name + '_' + e
else:
name = name + e
name = name
else:
name = con
tmp = cmds.spaceLocator(n=name + 'Aim')
aim_locator = setUniqueName(tmp[0], 'LOC')
aim_nul = homeNul(aim_locator)
tmp = cmds.spaceLocator(n=name + 'Target')
target_locator = setUniqueName(tmp[0], 'LOC')
target_nul = homeNul(target_locator)
tmp = cmds.spaceLocator(n=name + 'Offset')
offset_locator = setUniqueName(tmp[0], 'LOC')
offset_nul = homeNul(offset_locator)
tmp = cmds.group(aim_nul, target_nul, n=name + 'NoneFlip')
group = setUniqueName(tmp, 'GRP')
cmds.pointConstraint(base, aim_nul, w=True)
cmds.pointConstraint(target, target_nul, w=True)
cmds.delete(cmds.parentConstraint(con, offset_nul, w=True))
cmds.aimConstraint(target,
aim_locator,
w=True,
aim=[1, 0, 0],
u=[0, 1, 0],
wut='objectrotation',
wu=[1, 0, 0],
wuo=base)
sp = spaceBlend()
sp.parentBlend(offset_locator, 'move_CON', con)
cmds.parent(offset_nul, aim_locator)
cmds.parent(group, 'noneFlip_GRP')
return [aim_locator, target_locator, offset_locator]
def pivotToControllerOP(mySide):
myColor = 'blue'
if mySide == 'R':
myColor = 'red'
else:
pass
anklePivotName = '%s_ankleRoll_main_PIVOT' % mySide
pivotList = [ '%s_hindLeg_inSideRoll_PIVOT'% mySide, '%s_hindLeg_outSideRoll_PIVOT'% mySide, '%s_hindLeg_heelRoll_PIVOT'% mySide, '%s_hindLeg_toeRoll_PIVOT'% mySide, '%s_hindLeg_footTwist_PIVOT'% mySide, '%s_hindLeg_ballRoll_PIVOT'% mySide, '%s_hindLeg_toeTab_PIVOT'% mySide ]
pivotNulList = [ '%s_inSideRoll_hindLeg_NUL'% mySide ]
# create foot controller
ankleRollCONT = controllerShape( anklePivotName.replace( 'PIVOT', 'CON' ), 'cube', myColor )
cvNum = cmds.getAttr( '%s.spans' % ankleRollCONT ) + cmds.getAttr( '%s.degree' % ankleRollCONT )
cmds.select( '%s.cv[0:%s]' % ( ankleRollCONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % ankleRollCONT, anklePivotName, r=True, s=True )
cmds.delete( ankleRollCONT )
ankleRollCON = cmds.rename( anklePivotName, anklePivotName.replace( 'PIVOT', 'CON' ) )
for x in range( len( pivotList ) ):
CONT = controllerShape( pivotList[x].replace( 'PIVOT', 'CON' ), 'cube', myColor )
cvNum = cmds.getAttr( '%s.spans' % CONT ) + cmds.getAttr( '%s.degree' % CONT )
cmds.select( '%s.cv[0:%s]' % ( CONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % CONT, pivotList[x], r=True, s=True )
cmds.delete( CONT )
ankleRollCON = cmds.rename( pivotList[x], pivotList[x].replace( 'PIVOT', 'CON' ) )
# 2018/ 01.15 >> taehoon : change controller hierarchy!!!
cmds.parent( '%s_hindLeg_toeTab_NUL' % mySide, '%s_hindLeg_footTwist_CON' % mySide )
# make ankle controller by main ankle controller
myParent = '%s_rig_ball_JNT' % mySide
myMainCon = '%s_ankleRoll_main_CON' % mySide
myMainNul = '%s_ankleRoll_main_NUL' % mySide
myAimParnt = '%s_template_ankle_JNT' % mySide
myAimUp = '%s_template_knee_JNT' % mySide
myCon = controllerShape( myMainCon.replace( 'main_CON', 'CON' ), 'cube', myColor )
myNul = homeNul( myCon )
cmds.delete ( cmds.parentConstraint( myParent, myNul, mo=0 ) )
cmds.delete ( cmds.aimConstraint ( myAimParnt, myNul, aim=( 1, 0, 0 ), u=( 0, 1, 0 ), wut='object', wuo=myAimUp ) )
cmds.parentConstraint( myParent, myNul, mo=1 )
cmds.parentConstraint( myCon, myMainNul, mo=1 )
cmds.parent ( '%s_IK_ankle_SC_HDL' % mySide, myCon )
def fkAddSpineOP():
fkSpineJointList = [
'C_FKsub_spine1_NUL', 'C_FKsub_spine2_NUL', 'C_FKsub_spine3_NUL',
'C_FKsub_chest_NUL'
]
fkControllerMaker('circle', 'yellow', fkSpineJointList[1:3])
homeNul('C_IK_upBody_CON', 'C_IK_upBody_fkSubAttach_NUL')
cmds.parentConstraint('C_IK_lowBodySub_CON', fkSpineJointList[0], mo=True)
attachNode('C_FKsub_chest_NUL', 'C_IK_upBody_fkSubAttach_NUL', 'translate',
'rotate', 'scale', 'shear')
attachPart('C_IK_root_CON', 'C_FKsub_spine2_NUL_NUL', 'translate',
'rotate', 'scale', 'shear')
def fkAddNeckOP():
fkSpineJointList = [
'C_FK_neck1_NUL', 'C_FK_neck2_NUL', 'C_FK_neck3_NUL', 'C_FK_head_NUL'
]
fkControllerMaker('circle', 'yellow', fkSpineJointList[1:3])
homeNul('C_IK_head_CON', 'C_IK_head_extra_NUL')
cmds.parentConstraint('C_IK_neck1Sub_CON', fkSpineJointList[0], mo=True)
attachNode('C_FK_head_NUL', 'C_IK_head_extra_NUL', 'translate', 'rotate',
'scale', 'shear')
attachPart('C_IK_neck1_CON', 'C_FK_neck2_NUL', 'translate', 'rotate',
'scale', 'shear')
cmds.parent('C_FK_neck1_NUL', w=1)
def ikControllerMaker(target, handle):
z = defaultGroupNode()
z.createGroupNode()
par = cmds.listRelatives(target, p=True)
loc = cmds.spaceLocator(n=handle.split('_HDL')[0] + '_LOC')[0]
loc_nul = cmds.group(loc, n=loc.replace('_LOC', 'Space_NUL'))
sub = controllerShape(
handle.split('_HDL')[0] + 'Sub_CON', 'circle', 'yellow')
con = controllerShape(handle.split('_HDL')[0] + '_CON', 'cube', 'yellow')
vec = controllerShape(
handle.split('_HDL')[0] + 'Vec_CON', 'sphere', 'yellow')
snul = homeNul(sub)
cnul = homeNul(con)
vnul = homeNul(vec)
cmds.parent(loc_nul, sub)
cmds.parent(snul, con)
cmds.delete(cmds.pointConstraint(target, cnul, w=True))
cmds.delete(cmds.orientConstraint(target, snul, w=True))
cmds.delete(cmds.orientConstraint(con, loc_nul, w=True))
cmds.delete(cmds.pointConstraint(par, vnul, w=True))
cmds.parentConstraint(loc, handle, mo=True)
cmds.orientConstraint(loc, target, mo=True)
cmds.poleVectorConstraint(vec, handle, w=1)
cmds.rotate(0, 0, 90, sub + '.cv[*]', os=1)
cmds.setAttr(loc + '.v', 0)
cmds.parent(cnul, vnul, 'IKControl_GRP')
return [sub, con, vec], [snul, cnul, vnul]
def fkControllerMaker( conSahpe, colorShape, target ):
conList = []
constraintList = []
nulList = []
for x in range( len(target) ):
controllerName = controllerShape( target[x].split('_JNT')[0] + '_CON', conSahpe, colorShape )
POsnap( controllerName, target[x] )
PC = cmds.parentConstraint( controllerName, target[x] )
conList.append( controllerName )
constraintList.append( PC[0] )
for i in range(len(conList)-1):
cmds.parent( conList[i+1], conList[i] )
for e in conList:
NUL = homeNul( e )
nulList.append( NUL )
return conList, nulList, constraintList
def createController(self):
# create controller
foreLegControllerName = controllerShape(
self.IkForeLegJointList[3].replace('foot1_JNT', 'foreLeg_CON'),
'cube', 'blue')
cmds.move(self.wristPos[0], self.wristPos[1], self.wristPos[2],
foreLegControllerName)
shoulderContollerName = controllerShape(
self.IkForeLegJointList[0].replace('JNT', 'CON'), 'rombus', 'blue')
shoulderPos = cmds.xform(self.IkForeLegJointList[0],
t=True,
ws=True,
q=True)
cmds.move(shoulderPos[0], shoulderPos[1], shoulderPos[2],
shoulderContollerName)
elbowPVContollerName = controllerShape(
self.IkForeLegJointList[1].replace('JNT', 'CON'), 'sphere', 'blue')
elbowPVPos = cmds.xform(self.IkForeLegJointList[1],
t=True,
ws=True,
q=True)
cmds.move(elbowPVPos[0], elbowPVPos[1], elbowPVPos[2],
elbowPVContollerName)
# controller homeNull
homeNul(foreLegControllerName)
shoulderContollerNul = homeNul(shoulderContollerName)
homeNul(elbowPVContollerName)
# constraints & grouping
cmds.parent(self.pivotNulList[0], foreLegControllerName)
cmds.pointConstraint(self.clavicleIkJointList[1],
self.IkForeLegJointList[0])
cmds.pointConstraint(self.clavicleIkJointList[1],
self.subIkJointList[0])
cmds.poleVectorConstraint(elbowPVContollerName, self.G_RPName)
cmds.poleVectorConstraint(elbowPVContollerName, self.RPsName)
# add attr
cmds.addAttr(foreLegControllerName,
longName='foot',
at='enum',
en='Controls',
keyable=True)
cmds.setAttr('%s.foot' % foreLegControllerName, lock=True)
#########################################################################################################################
# create clavicle controller
clavicleControllerName = controllerShape(
self.clavicleIkJointList[0].replace('JNT', 'CON'), 'cube', 'blue')
Psnap(clavicleControllerName, self.clavicleIkJointList[0])
clavicleControllerRotZNul = homeNul(
clavicleControllerName,
clavicleControllerName.replace('_CON', 'RotZ_NUL'))
clavicleControllerNul = homeNul(
clavicleControllerRotZNul,
clavicleControllerName.replace('_CON', '_NUL'))
# create clavicle
cmds.aimConstraint(foreLegControllerName,
clavicleControllerRotZNul,
mo=True,
worldUpType='none',
skip=['x', 'y'])
cmds.setKeyframe('%s.rz' % clavicleControllerRotZNul)
cmds.disconnectAttr('pairBlend1_inRotateZ1.output',
'pairBlend1.inRotateZ1')
cmds.delete('pairBlend1_inRotateZ1')
cmds.rename('pairBlend1', 'L_clvicleRotZ_PBD')
# add attr autoClavicle
cmds.addAttr(foreLegControllerName,
longName='auto',
at='enum',
en='Shoulder',
keyable=True)
cmds.setAttr('%s.foot' % foreLegControllerName, lock=True)
cmds.addAttr(foreLegControllerName,
longName='front',
at='double',
keyable=True,
attributeType='float',
min=0,
max=1,
dv=0.5)
# connection
cmds.connectAttr('%s.front' % foreLegControllerName,
'%s.blendAim1' % clavicleControllerRotZNul)
clavicleSc = ikHandleMaker(self.clavicleIkJointList[0],
self.clavicleIkJointList[1], 'ikSCsolver')
clavicleScName = cmds.rename(
clavicleSc[0],
self.clavicleIkJointList[0].replace('JNT', 'SC_HDL'))
clavicleScEffectorName = cmds.rename(
clavicleSc[1],
self.clavicleIkJointList[0].replace('JNT', 'SC_IKEFFECTOR'))
cmds.pointConstraint(clavicleControllerName,
self.clavicleIkJointList[0],
mo=True)
cmds.parent(clavicleScName, clavicleControllerName)
cmds.pointConstraint(shoulderContollerName, clavicleScName, mo=True)
cmds.parent(shoulderContollerNul, clavicleControllerName)
# create foot controller wristPivotName
wristRollCONT = controllerShape(
self.wristPivotName.replace('PIVOT', 'CON'), 'cube', 'yellow')
cvNum = cmds.getAttr('%s.spans' % wristRollCONT) + cmds.getAttr(
'%s.degree' % wristRollCONT)
cmds.select('%s.cv[0:%s]' % (wristRollCONT, cvNum - 1))
cmds.scale(0.5, 0.5, 0.5)
cmds.select(cl=True)
cmds.parent('%sShape' % wristRollCONT,
self.wristPivotName,
r=True,
s=True)
cmds.delete(wristRollCONT)
wristRollCON = cmds.rename(self.wristPivotName,
self.wristPivotName.replace('PIVOT', 'CON'))
for x in range(len(self.pivotList)):
CONT = controllerShape(self.pivotList[x].replace('PIVOT', 'CON'),
'cube', 'yellow')
cvNum = cmds.getAttr('%s.spans' % CONT) + cmds.getAttr(
'%s.degree' % CONT)
cmds.select('%s.cv[0:%s]' % (CONT, cvNum - 1))
cmds.scale(0.5, 0.5, 0.5)
cmds.select(cl=True)
cmds.parent('%sShape' % CONT, self.pivotList[x], r=True, s=True)
cmds.delete(CONT)
wristRollCON = cmds.rename(
self.pivotList[x], self.pivotList[x].replace('PIVOT', 'CON'))
def L_ikHindLegOP():
hindLegIkJointList = [
'L_IK_hip_JNT', 'L_IK_knee_JNT', 'L_IK_ankle_JNT', 'L_IK_ball_JNT',
'L_IK_toe_JNT', 'L_IK_toeTip_JNT'
]
footTemplateLocLict = [
'L_hindLeg_inSideRollTemple', 'L_hindLeg_outSideRollTemple',
'L_hindLeg_heelRollTemple', 'L_hindLeg_toeRollTemple',
'L_hindLeg_footTwistTemple', 'L_hindLeg_ballRollTemple',
'L_hindLeg_toeTabTemple'
]
# separate duplicate for ikSpringSolver
sSJointList = []
dList = cmds.duplicate(hindLegIkJointList[0], renameChildren=True)
for x in range(len(dList)):
rN = cmds.rename(dList[x], dList[x].replace('IK', 'rig')[0:-1])
sSJointList.append(rN)
cmds.delete(sSJointList[4])
del sSJointList[4:]
# create IK
RPs = ikHandleMaker(hindLegIkJointList[0], hindLegIkJointList[2],
'ikRPsolver')
RPsName = cmds.rename(RPs[0],
hindLegIkJointList[0].replace('JNT', 'RP_HDL'))
RPsEffectorName = cmds.rename(
RPs[1], hindLegIkJointList[0].replace('JNT', 'RP_IKEFFECTOR'))
SCs1 = ikHandleMaker(hindLegIkJointList[2], hindLegIkJointList[3],
'ikSCsolver')
SCs1Name = cmds.rename(RPs[0],
hindLegIkJointList[2].replace('JNT', 'SC_HDL'))
SCs1EffectorName = cmds.rename(
RPs[1], hindLegIkJointList[2].replace('JNT', 'SC_IKEFFECTOR'))
SCs2 = ikHandleMaker(hindLegIkJointList[3], hindLegIkJointList[4],
'ikSCsolver')
SCs2Name = cmds.rename(RPs[0],
hindLegIkJointList[3].replace('JNT', 'SC_HDL'))
SCs2EffectorName = cmds.rename(
RPs[1], hindLegIkJointList[3].replace('JNT', 'SC_IKEFFECTOR'))
SCs3 = ikHandleMaker(hindLegIkJointList[4], hindLegIkJointList[5],
'ikSCsolver')
SCs3Name = cmds.rename(RPs[0],
hindLegIkJointList[4].replace('JNT', 'SC_HDL'))
SCs3EffectorName = cmds.rename(
RPs[1], hindLegIkJointList[4].replace('JNT', 'SC_IKEFFECTOR'))
mel.eval('ikSpringSolver;')
Ss = cmds.ikHandle(sj=sSJointList[0],
ee=sSJointList[3],
sol='ikSpringSolver')
SsName = cmds.rename(RPs[0], sSJointList[0].replace('JNT', 'SS_HDL'))
SsEffectorName = cmds.rename(
RPs[1], sSJointList[0].replace('JNT', 'SS_IKEFFECTOR'))
####################################################################################################################################
IST = footTemplateLocLict[0]
OST = footTemplateLocLict[1]
HRT = footTemplateLocLict[2]
TRT = footTemplateLocLict[3]
FTT = footTemplateLocLict[4]
BRT = footTemplateLocLict[5]
TTT = cmds.spaceLocator(n=footTemplateLocLict[6])
pSnap(TTT[0], hindLegIkJointList[-2])
####################################################################################################################################
# create pivot positon
pivotList = []
pivotNulList = []
for x in range(len(footTemplateLocLict)):
PL = cmds.group(em=True,
n=footTemplateLocLict[x].replace('Temple', '_PIVOT'))
pSnap(PL, footTemplateLocLict[x])
pivotList.append(PL)
for x in range(len(pivotList) - 1):
cmds.parent(pivotList[x + 1], pivotList[x])
for x in range(len(pivotList)):
PH = homeNul(pivotList[x])
pivotNulList.append(PH)
cmds.parent(SCs2Name, pivotList[5])
cmds.parent(SCs3Name, pivotList[-1])
anklePivotName = cmds.group(em=True, n='L_ankleRoll_main_PIVOT')
anklePos = cmds.xform(hindLegIkJointList[3], t=True, ws=True, q=True)
cmds.move(anklePos[0], anklePos[1], anklePos[2], anklePivotName)
cmds.parent(anklePivotName, sSJointList[2])
homeNul(anklePivotName)
# create controller
haindLegControllerName = controllerShape(
hindLegIkJointList[3].replace('ball_JNT', 'hindLeg_CON'), 'cube',
'blue')
cmds.move(anklePos[0], anklePos[1], anklePos[2], haindLegControllerName)
hipContollerName = controllerShape(
hindLegIkJointList[0].replace('JNT', 'CON'), 'cube', 'blue')
hipPos = cmds.xform(hindLegIkJointList[0], t=True, ws=True, q=True)
cmds.move(hipPos[0], hipPos[1], hipPos[2], hipContollerName)
kneePVContollerName = controllerShape(
hindLegIkJointList[1].replace('JNT', 'CON'), 'sphere', 'blue')
kneePVPos = cmds.xform(hindLegIkJointList[1], t=True, ws=True, q=True)
cmds.move(kneePVPos[0], kneePVPos[1], kneePVPos[2], kneePVContollerName)
# controller homeNull
homeNul(haindLegControllerName)
homeNul(hipContollerName)
homeNul(kneePVContollerName)
# constraints & grouping
cmds.parent(pivotNulList[0], haindLegControllerName)
cmds.pointConstraint(hipContollerName, hindLegIkJointList[0])
cmds.pointConstraint(hipContollerName, sSJointList[0])
cmds.poleVectorConstraint(kneePVContollerName, SsName)
cmds.poleVectorConstraint(sSJointList[1], RPsName)
cmds.parent(SsName, pivotList[5])
cmds.parent(RPsName, anklePivotName)
# add Attr
cmds.addAttr(haindLegControllerName,
longName='foot',
at='enum',
en='Controls',
keyable=True)
cmds.setAttr('%s.foot' % haindLegControllerName, lock=True)
cmds.addAttr(haindLegControllerName,
longName='leg',
at='enum',
en='Angle',
keyable=True)
cmds.setAttr('%s.leg' % haindLegControllerName, lock=True)
cmds.addAttr(haindLegControllerName,
longName='angle',
at='double',
keyable=True,
attributeType='float',
min=-10,
max=10,
dv=0)
SAB0 = cmds.createNode('setRange',
n=haindLegControllerName.replace(
'_CON', 'SAB0_RNG'))
SAB1 = cmds.createNode('setRange',
n=haindLegControllerName.replace(
'_CON', 'SAB1_RNG'))
cmds.setAttr('%s.minX' % SAB0, 0)
cmds.setAttr('%s.maxX' % SAB0, 1)
cmds.setAttr('%s.oldMinX' % SAB0, -10)
cmds.setAttr('%s.oldMaxX' % SAB0, 10)
cmds.setAttr('%s.minX' % SAB1, 1)
cmds.setAttr('%s.maxX' % SAB1, 0)
cmds.setAttr('%s.oldMinX' % SAB1, -10)
cmds.setAttr('%s.oldMaxX' % SAB1, 10)
cmds.connectAttr('%s.angle' % haindLegControllerName, '%s.valueX' % SAB0)
cmds.connectAttr(
'%s.outValue.outValueX' % SAB0,
'%s.springAngleBias[0].springAngleBias_FloatValue' % SsName)
cmds.connectAttr('%s.angle' % haindLegControllerName, '%s.valueX' % SAB1)
cmds.connectAttr(
'%s.outValue.outValueX' % SAB1,
'%s.springAngleBias[1].springAngleBias_FloatValue' % SsName)
def splineControllerMaker(crv,handle):
list=[]
#씬안에 필요한 group node생성
z=defaultGroupNode()
z.createGroupNode()
par= cmds.listRelatives (crv,p=True)
locs= setUpCurve (crv)
for e in locs:
tmp= cmds.rename(e,e.replace('_LOC','Attach'))
name=setUniqueName(tmp,'LOC')
nul= homeNul(name)
cmds.parent(nul,'attach_GRP')
list.append(nul)
low= controllerShape('C_IK_lowBody','cube','yellow')
lowBody=setUniqueName(low,'CON')
up= controllerShape( 'C_IK_upBody','cube','yellow')
upBody=setUniqueName(up,'CON')
lowNul= homeNul(lowBody)
upNul= homeNul(upBody)
cmds.parent(upNul,lowNul,'IKControl_GRP')
cmds.delete(cmds.parentConstraint(list[0],lowNul,w=True))
cmds.delete(cmds.parentConstraint(list[-1],upNul,w=True))
for i in range(len(list)):
chd= cmds.listRelatives(list[i],c=True)
cmds.parent(chd[0],w=True)
if i <= 1:
mmx=cmds.createNode ('multMatrix')
dcm=cmds.createNode ('decomposeMatrix')
cmds.connectAttr (lowBody+'.worldMatrix',mmx+'.matrixIn[0]',f=True)
cmds.connectAttr (list[i]+'.parentInverseMatrix',mmx+'.matrixIn[1]',f=True)
cmds.connectAttr (mmx+'.matrixSum',dcm+'.inputMatrix',f=True)
cmds.connectAttr (dcm+'.outputTranslate',list[i]+'.t',f=True)
cmds.connectAttr (dcm+'.outputRotate',list[i]+'.r',f=True)
cmds.parent(chd,list[i])
else:
mmx=cmds.createNode ('multMatrix')
dcm=cmds.createNode ('decomposeMatrix')
cmds.connectAttr (upBody+'.worldMatrix',mmx+'.matrixIn[0]',f=True)
cmds.connectAttr (list[i]+'.parentInverseMatrix',mmx+'.matrixIn[1]',f=True)
cmds.connectAttr (mmx+'.matrixSum',dcm+'.inputMatrix',f=True)
cmds.connectAttr (dcm+'.outputTranslate',list[i]+'.t',f=True)
cmds.connectAttr (dcm+'.outputRotate',list[i]+'.r',f=True)
cmds.parent(chd,list[i])
cmds.setAttr (handle+'.dTwistControlEnable',1)
cmds.setAttr (handle+'.dWorldUpType',4)
cmds.setAttr (handle+'.dWorldUpVector', 0,0,1)
cmds.setAttr (handle+'.dWorldUpVectorEnd',0,0,1)
cmds.connectAttr (lowBody+'.worldMatrix[0]',handle+'.dWorldUpMatrix',f=1)
cmds.connectAttr (upBody+'.worldMatrix[0]',handle+'.dWorldUpMatrixEnd',f=1)
#FK컨트롤러 생성및 세팅
sp1= controllerShape('C_IK_upBodyRot1','circle','yellow')
spine1=setUniqueName(sp1,'CON')
spNul1= homeNul(spine1)
sp2= controllerShape('C_IK_upBodyRot2','circle','yellow')
spine2=setUniqueName(sp2,'CON')
spNul2= homeNul(spine2)
cmds.delete(cmds.parentConstraint(list[1].replace('NUL','LOC'),spNul1,w=True))
cmds.delete(cmds.parentConstraint(list[2].replace('NUL','LOC'),spNul2,w=True))
cmds.parent (spNul2,spine1)
cmds.parent(spNul1,'IKControl_GRP')
return [lowBody,upBody]
def setIK(self,*jnt):
buffer=[]
copied=[]
tmp=cmds.listRelatives (jnt[0],c=1,ad=1)
c=jnt[0]
buffer.append(c)
for i in range(len(tmp)):
if jnt[-1] in c:
break
else:
c=cmds.listRelatives (c,c=True)
buffer.append(c[0])
#조인트 복사 및 중복된 네임 정리
for e in buffer:
name=e.split('_')[0]+'_IK_'+e.split('_')[2]
dup= cmds.duplicate (e,n=name,rr=True,rc=True)
tmp= setUniqueName(dup[0],'JNT')
par= cmds.listRelatives (tmp,p=True,typ='joint')
chi= cmds.listRelatives (tmp,c=True,typ='joint')
if par is not None:
if len(copied) is not 0:
cmds.parent (tmp,copied[-1])
if cmds.connectionInfo (tmp+'.inverseScale',id=True) is False:
cmds.connectAttr (copied[-1]+'.scale',tmp+'.inverseScale',f=True)
if chi is not None:
cmds.delete (chi)
copied.append(tmp)
cmds.parent(copied[0],'IKJoint_GRP')
tmp= ikHandleMaker( copied[0], copied[-2], 'ikRPsolver' )
hdl= cmds.rename (tmp[0],copied[-2].replace('JNT','HDL'))
cmds.setAttr (hdl+'.v',0)
cmds.parent (hdl,'auxillary_GRP')
self.IkCon=ikControllerMaker( copied[-2] ,hdl)
otherCon= fkControllerMaker( 'circle', 'yellow', [copied[-1]] )
cmds.delete(otherCon[2])
cmds.orientConstraint (otherCon[0],copied[-1],w=True)
ballUp= controllerShape(otherCon[0][0].replace('_CON','RollUp_CON'),'hexagon', 'yellow' )
ballUp_Nul= homeNul (ballUp)
cmds.delete(cmds.pointConstraint (copied[-1],ballUp_Nul,w=True))
cmds.rotate (90,0,0,ballUp+'.cv[*]',os=1)
heelUp= controllerShape(self.IkCon[0][1].replace('_CON','RollUp_CON'),'hexagon', 'yellow' )
heelUp_Nul= homeNul (heelUp)
cmds.delete(cmds.pointConstraint (copied[-2],heelUp_Nul,offset=(0,-1,-1),w=True))
cmds.rotate (90,0,0,heelUp+'.cv[*]',os=1)
self.IkCon[0].append(str(otherCon[0][0]))
self.IkCon[1].append(str(otherCon[1][0]))
cmds.parent (self.IkCon[1][3],ballUp_Nul,heelUp_Nul,self.IkCon[0][0])
#rolling up
roll=addRollingUp()
tmp=roll.rollUp(self.IkCon[0][1].replace('_CON','_LOC'),ballUp,heelUp)
cmds.parent (tmp,'roll_GRP')
#attach shoulder
tmp=attachPart2(heelUp ,self.IkCon[1][3] , 'translate','rotate','scale','shear')
cmds.parent(tmp,'attach_GRP')
#connect stretchy
st=stretchyLock()
if cmds.objExists (self.IkCon[0][1].replace('_CON','_LOC')) is True:
st.setStretchyLock(self.IkCon[0][1],self.IkCon[0][2],self.IkCon[0][1].replace('_CON','_LOC'),copied[0],copied[1],copied[2])
else:
tempString= cmds.spaceLocator (n=self.IkCon[0][1].replace('_CON','_LOC'))
cmds.parent (tempString,self.IkCon[0][1].replace('_CON','Sub_CON'))
st.setStretchyLock(self.IkCon[0][1],self.IkCon[0][2],self.IkCon[0][1].replace('_CON','_LOC'),copied[0],copied[1],copied[2])
n=noneFlip()
n.setup(self.IkCon[0][1].replace('_CON','_LOC'),copied[0],self.IkCon[0][2])
cmds.rotate (90,0,0,self.IkCon[0][3]+'.cv[*]',os=1)
return self.IkCon[0]
def neckControllerMaker(crv,handle):
list=[]
#씬안에 필요한 group node생성
z=defaultGroupNode()
z.createGroupNode()
par= cmds.listRelatives (crv,p=True)
locs= setUpCurve (crv)
for e in locs:
tmp= cmds.rename(e,e.replace('_LOC','Attach'))
name=setUniqueName(tmp,'LOC')
nul= homeNul(name)
cmds.parent(nul,'attach_GRP')
list.append(nul)
low= controllerShape('C_IK_neck','cube','yellow')
neck=setUniqueName(low,'CON')
up= controllerShape( 'C_IK_head','cube','yellow')
head=setUniqueName(up,'CON')
neckNul= homeNul(neck)
headNul= homeNul(head)
cmds.parent(headNul,neckNul,'IKControl_GRP')
cmds.delete(cmds.parentConstraint(list[0],neckNul,w=True))
cmds.delete(cmds.parentConstraint(list[-1],headNul,w=True))
for i in range(len(list)):
chd= cmds.listRelatives(list[i],c=True)
cmds.parent(chd[0],w=True)
if i == 0:
mmx=cmds.createNode ('multMatrix')
dcm=cmds.createNode ('decomposeMatrix')
cmds.connectAttr (neck+'.worldMatrix',mmx+'.matrixIn[0]',f=True)
cmds.connectAttr (list[i]+'.parentInverseMatrix',mmx+'.matrixIn[1]',f=True)
cmds.connectAttr (mmx+'.matrixSum',dcm+'.inputMatrix',f=True)
cmds.connectAttr (dcm+'.outputTranslate',list[i]+'.t',f=True)
cmds.connectAttr (dcm+'.outputRotate',list[i]+'.r',f=True)
cmds.parent(chd,list[i])
else:
mmx=cmds.createNode ('multMatrix')
dcm=cmds.createNode ('decomposeMatrix')
cmds.connectAttr (head+'.worldMatrix',mmx+'.matrixIn[0]',f=True)
cmds.connectAttr (list[i]+'.parentInverseMatrix',mmx+'.matrixIn[1]',f=True)
cmds.connectAttr (mmx+'.matrixSum',dcm+'.inputMatrix',f=True)
cmds.connectAttr (dcm+'.outputTranslate',list[i]+'.t',f=True)
cmds.connectAttr (dcm+'.outputRotate',list[i]+'.r',f=True)
cmds.parent(chd,list[i])
cmds.setAttr (handle+'.dTwistControlEnable',1)
cmds.setAttr (handle+'.dWorldUpType',3)
cmds.setAttr (handle+'.dWorldUpVector', 0,0,1)
cmds.connectAttr (neck+'.worldMatrix[0]',handle+'.dWorldUpMatrix',f=1)
return [neck,head]
from baseRig.util.fkControllerMaker import *
from baseRig.util.snap import *
from baseRig.util.homeNul import *
from baseRig.util.attach import *
fkSpineJointList = [
'C_FKsub_spine1_NUL', 'C_FKsub_spine2_NUL', 'C_FKsub_spine3_NUL',
'C_FKsub_chest_NUL'
]
fkControllerMaker('circle', 'yellow', fkSpineJointList[1:3])
homeNul('C_IK_upBody_CON', 'C_IK_upBody_fkSubAttach_NUL')
cmds.parentConstraint('C_IK_lowBodySub_CON', fkSpineJointList[0], mo=True)
attachNode('C_FKsub_chest_NUL', 'C_IK_upBody_fkSubAttach_NUL', 'translate',
'rotate', 'scale', 'shear')
attachPart('C_IK_root_CON', 'C_FKsub_spine2_NUL_NUL', 'translate', 'rotate',
'scale', 'shear')
def setBlend(self,hip,*jnt):
buffer=[]
copied=[]
const=[]
crv=''
tmp=cmds.listRelatives (jnt[0],c=1,ad=1)
c=jnt[0]
buffer.append(c)
if tmp is not None:
for i in range(len(tmp)):
if jnt[-1] in c:
break
else:
c=cmds.listRelatives (c,c=True)
buffer.append(c[0])
#조인트 복사 및 중복된 네임 정리
for e in buffer:
name=e.split('_')[0]+'_Blend_'+e.split('_')[2]
dup= cmds.duplicate (e,n=name,rr=True,rc=True)
tmp= setUniqueName(dup[0],'JNT')
par= cmds.listRelatives (tmp,p=True,typ='joint')
chi= cmds.listRelatives (tmp,c=True,typ='joint')
if par is not None:
if len(copied) is not 0:
cmds.parent (tmp,copied[-1])
if cmds.connectionInfo (tmp+'.inverseScale',id=True) is False:
cmds.connectAttr (copied[-1]+'.scale',tmp+'.inverseScale',f=True)
if chi is not None:
cmds.delete (chi)
copied.append(tmp)
cmds.parent(copied[0],'BlendJoint_GRP')
#스위치 콘트롤러 생성
prefix= copied[0].split('_')[0]
buf= controllerShape(prefix+'_legBlend','fatCross','yellow')
sw= setUniqueName(buf,'CON')
swNul= homeNul(sw)
sha= cmds.listRelatives (sw,s=True,typ='nurbsCurve')
cmds.rotate (90,0,0,sha[0]+'.cv[*]',os=1)
cmds.scale (0.5,0.5,0.5,sha[0]+'.cv[*]',os=1)
v= cmds.getAttr (copied[0]+'.tx')
cmds.delete(cmds.pointConstraint (copied[0],swNul,w=True,offset=(v/(abs(v)),1,0)))
cmds.addAttr (sw,ln ='FKIKBlend',at='double',min= 0 ,max= 1 ,dv= 0)
cmds.setAttr (sw+'.FKIKBlend',e=True,keyable=True)
cmds.addAttr (sw,ln ='FKConVis',at='bool')
cmds.setAttr (sw+'.FKConVis',e=True,keyable=True)
cmds.addAttr (sw,ln ='IKConVis',at='bool')
cmds.setAttr (sw+'.IKConVis',e=True,keyable=True)
cmds.parent (swNul,'otherControl_GRP')
for e in copied:
if cmds.objExists (e.replace('Blend','FK')) :
const.append(cmds.parentConstraint (e.replace('Blend','FK'),e,w= 1)[0])
if cmds.objExists (e.replace('Blend','IK')):
const.append(cmds.parentConstraint (e.replace('Blend','IK'),e,w= 1)[0])
for e in const:
buf= cmds.parentConstraint (e,q=True,tl=True)
if len(buf) is 2:
z=connectSwitch()
z.FKIKConstraint(sw,e)
else:
cmds.delete(swNul)
break
for e in self.FkCon[0]:
z=connectSwitch()
z.ConnectFKVisibility(sw,e.replace('_CON','_NUL'))
for e in self.IkCon[0]:
z=connectSwitch()
z.ConnectIKVisibility(sw,e.replace('_CON','_NUL'))
#twist setup
t=twistSetUp()
t.blendTwist(hip,copied[0],copied[1],5)
t.blendTwist(copied[0],copied[1],copied[2],5)
#skin setup
s=setSkinJoint()
s.set()
return copied
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
def createIkSpineSet(self):
IKH = ikHandleMaker(self.spineJointList[1], self.spineJointList[-1],
'ikSplineSolver')
print IKH
IKH = [u'ikHandle1', u'effector1', u'curve1']
handleName = cmds.rename(IKH[0], 'C_IK_spine1_HDL')
effectorName = cmds.rename(IKH[1], 'C_IK_spine1_EFFECTOR')
curveName = cmds.rename(IKH[2], 'C_IK_spine1_CRV')
cmds.rebuildCurve(curveName, s=2, d=3)
locatorName = curveToLocatorFix(curveName)
print locatorName
cmds.parent(curveName, w=True)
for x in range(len(locatorName)):
NUL = homeNul(locatorName[x])
self.locatorNulList.append(NUL)
# Advanced Twist Controls Set
upLoc = cmds.spaceLocator(n=self.upBody.replace('CON', 'aTwist_LOC'))
POsnap(upLoc, self.spineJointList[-1])
cmds.parent(upLoc, self.upBodySubCon)
#[u'C_IK_root_JNT', u'C_IK_spine1_JNT', u'C_IK_spine2_JNT', u'C_IK_spine3_JNT', u'C_IK_chest_JNT']
lowLoc = cmds.spaceLocator(n=self.lowBody.replace('CON', 'aTwist_LOC'))
POsnap(lowLoc, self.spineJointList[1])
cmds.parent(lowLoc, self.lowBodySubCon)
cmds.setAttr('%s.dTwistControlEnable' % handleName, 1)
cmds.setAttr('%s.dWorldUpType' % handleName, 4)
cmds.setAttr('%s.dWorldUpAxis' % handleName, 0)
cmds.setAttr('%s.dWorldUpVectorX' % handleName, 0)
cmds.setAttr('%s.dWorldUpVectorY' % handleName, 1)
cmds.setAttr('%s.dWorldUpVectorZ' % handleName, 0)
cmds.setAttr('%s.dWorldUpVectorEndX' % handleName, 0)
cmds.setAttr('%s.dWorldUpVectorEndY' % handleName, 1)
cmds.setAttr('%s.dWorldUpVectorEndZ' % handleName, 0)
cmds.connectAttr('%s.worldMatrix' % lowLoc[0],
'%s.dWorldUpMatrix' % handleName)
cmds.connectAttr('%s.worldMatrix' % upLoc[0],
'%s.dWorldUpMatrixEnd' % handleName)
#
cmds.orientConstraint(self.upBodySubCon,
self.spineJointList[-1],
mo=True)
#print self.locatorNulList[u'C_IK_spine1_NUL', u'C_IK_spine2_NUL', u'C_IK_spine3_NUL', u'C_IK_spine4_NUL']
AP_low0 = attachPart(self.lowBodySubCon, self.locatorNulList[0],
'translate', 'rotate', 'scale', 'shear')
AP_low1 = attachPart(self.lowBodySubCon, self.locatorNulList[1],
'translate', 'rotate', 'scale', 'shear')
AP_up4 = attachPart(self.upBodySubCon, self.locatorNulList[3],
'translate', 'rotate', 'scale', 'shear')
AP_up5 = attachPart(self.upBodySubCon, self.locatorNulList[4],
'translate', 'rotate', 'scale', 'shear')
cmds.parentConstraint(self.hipCon, self.spineJointList[0], mo=True)
#......
AP_lowBoy = attachPart(self.spineControllerList[0], self.lowBodyNul,
'translate', 'rotate', 'scale', 'shear')
AP_upBoy = attachPart(self.spineControllerList[0], self.upBodyNul,
'translate', 'rotate', 'scale', 'shear')
#...
#noneScaleSpineGroup = cmds.group( handleName, curveName, self.locatorNulList[0], self.locatorNulList[1], self.locatorNulList[2], self.locatorNulList[3],
# self.locatorNulList[4], self.locatorNulList[5], name='noneScaleSpine_GRP' )
"""
cmds.parent( noneScaleSpineGroup, 'noneScale_GRP' )
cmds.parent( self.spineJointList[0], 'C_IK_spineJoint_GRP' )
cmds.parent( self.spineControllerNulList[0], 'C_move_CON' )
cmds.parent( self.lowBodyNul, 'C_IK_spineController_GRP' )
cmds.parent( self.upBodyNul, 'C_IK_spineController_GRP' )
cmds.parent( AP_low0, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_low1, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_low2, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_up3, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_up4, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_up5, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_lowBoy, 'C_IK_spineAttach_GRP' )
cmds.parent( AP_upBoy, 'C_IK_spineAttach_GRP' )
"""
spineMiddleCon = controllerShape('C_IK_spineMiddle_CON', 'hexagon',
'yellow')
print spineMiddleCon
#POsnap( spineMiddleCon, self.locatorNulList[2] )
cmds.delete(
cmds.parentConstraint(self.upBody, self.lowBody, spineMiddleCon))
spineMiddleConNul = homeNul(spineMiddleCon)
cmds.parentConstraint(self.upBodySubCon,
self.lowBodySubCon,
spineMiddleConNul,
mo=True)
attachPart(spineMiddleCon, self.locatorNulList[2], 'translate',
'rotate', 'scale', 'shear')
mySpineJnt1 = 'C_template_spine1_JNT'
mySpineJnt2 = 'C_template_spine2_JNT'
mySpineJnt3 = 'C_template_spine3_JNT'
mySpineJnt4 = 'C_template_spine4_JNT'
myChestJnt = 'C_template_chest_JNT'
# make nul
mySpineNul1 = cmds.group(em=True, name='C_FKsub_spine1_NUL')
cmds.delete(
cmds.parentConstraint(self.spineTempJointList[1], mySpineNul1))
mySpineNul2 = cmds.group(em=True, name='C_FKsub_spine2_NUL')
cmds.delete(
cmds.parentConstraint(self.spineTempJointList[1],
self.spineTempJointList[4], mySpineNul2))
mySpineNul3 = cmds.group(em=True, name='C_FKsub_spine3_NUL')
cmds.delete(
cmds.parentConstraint(self.spineTempJointList[7],
self.spineTempJointList[4], mySpineNul3))
myChestNul = cmds.group(em=True, name='C_FKsub_chest_NUL')
cmds.delete(
cmds.parentConstraint(self.spineTempJointList[7], myChestNul))
# nul parent
cmds.parent(myChestNul, mySpineNul3)
cmds.parent(mySpineNul3, mySpineNul2)
cmds.parent(mySpineNul2, mySpineNul1)
def createController(self):
# create controller
foreLegControllerName = controllerShape(
self.IkForeLegJointList[4].replace('foot1_JNT', 'foreLeg_CON'),
'cube', 'blue')
cmds.move(self.wristPos[0], self.wristPos[1], self.wristPos[2],
foreLegControllerName)
clavicleControllerName = controllerShape(
self.IkForeLegJointList[0].replace('JNT', 'CON'), 'cube', 'blue')
shoulderPos = cmds.xform(self.IkForeLegJointList[0],
t=True,
ws=True,
q=True)
shoulderRot = cmds.xform(self.IkForeLegJointList[0],
ro=True,
ws=True,
q=True)
cmds.move(shoulderPos[0], shoulderPos[1], shoulderPos[2],
clavicleControllerName)
cmds.rotate(shoulderRot[0], shoulderRot[1], shoulderRot[2],
clavicleControllerName)
clavicleWorldControllerName = controllerShape(
self.IkForeLegJointList[0].replace('JNT', 'world_CON'), 'cube',
'blue')
cmds.move(shoulderPos[0], shoulderPos[1], shoulderPos[2],
clavicleWorldControllerName)
elbowPVContollerName = controllerShape(
self.IkForeLegJointList[2].replace('JNT', 'CON'), 'sphere', 'blue')
elbowPVPos = cmds.xform(self.IkForeLegJointList[2],
t=True,
ws=True,
q=True)
cmds.move(elbowPVPos[0], elbowPVPos[1], elbowPVPos[2],
elbowPVContollerName)
# controller homeNull
homeNul(foreLegControllerName)
shoulderContollerNul = homeNul(clavicleControllerName)
elbowPVContollerNameNul = homeNul(elbowPVContollerName)
cmds.select(elbowPVContollerNameNul)
cmds.move(-5, r=True, z=True)
clavicleWorldControllerNul = homeNul(clavicleWorldControllerName)
# constraints & grouping
cmds.parent(self.pivotNulList[0], foreLegControllerName)
cmds.parent(shoulderContollerNul, clavicleWorldControllerName)
# add attr
cmds.addAttr(foreLegControllerName,
longName='foot',
at='enum',
en='Controls',
keyable=True)
cmds.setAttr('%s.foot' % foreLegControllerName, lock=True)
#########################################################################################################################
# create clavicleControllerRotZNul
clavicleControllerRotZNul = homeNul(
clavicleControllerName,
clavicleControllerName.replace('_CON', 'RotZ_NUL'))
# create clavicle
cmds.aimConstraint(foreLegControllerName,
clavicleControllerRotZNul,
mo=True,
worldUpType='none',
skip=['x', 'y'])
cmds.setKeyframe('%s.rz' % clavicleControllerRotZNul)
cmds.disconnectAttr('pairBlend1_inRotateZ1.output',
'pairBlend1.inRotateZ1')
cmds.delete('pairBlend1_inRotateZ1')
cmds.rename('pairBlend1', 'L_clvicleRotZ_PBD')
# add attr autoClavicle
cmds.addAttr(foreLegControllerName,
longName='auto',
at='enum',
en='Shoulder',
keyable=True)
cmds.setAttr('%s.auto' % foreLegControllerName, lock=True)
cmds.addAttr(foreLegControllerName,
longName='front',
at='double',
keyable=True,
attributeType='float',
min=0,
max=1,
dv=0.5)
# connection
cmds.connectAttr('%s.front' % foreLegControllerName,
'%s.blendAim1' % clavicleControllerRotZNul)
# parentConstraint
cmds.parentConstraint(clavicleControllerName,
self.IkForeLegJointList[0],
mo=True)
cmds.parentConstraint(clavicleControllerName,
self.subIkJointList[0],
mo=True)
# create foot controller
wristRollCONT = controllerShape(
self.wristPivotName.replace('PIVOT', 'CON'), 'cube', 'yellow')
cvNum = cmds.getAttr('%s.spans' % wristRollCONT) + cmds.getAttr(
'%s.degree' % wristRollCONT)
cmds.select('%s.cv[0:%s]' % (wristRollCONT, cvNum - 1))
cmds.scale(1.5, 1.5, 1.5)
cmds.select(cl=True)
cmds.parent('%sShape' % wristRollCONT,
self.wristPivotName,
r=True,
s=True)
cmds.delete(wristRollCONT)
wristRollCON = cmds.rename(self.wristPivotName,
self.wristPivotName.replace('PIVOT', 'CON'))
for x in range(len(self.pivotList)):
CONT = controllerShape(self.pivotList[x].replace('PIVOT', 'CON'),
'cube', 'yellow')
cvNum = cmds.getAttr('%s.spans' % CONT) + cmds.getAttr(
'%s.degree' % CONT)
cmds.select('%s.cv[0:%s]' % (CONT, cvNum - 1))
cmds.scale(0.5, 0.5, 0.5)
cmds.select(cl=True)
cmds.parent('%sShape' % CONT, self.pivotList[x], r=True, s=True)
cmds.delete(CONT)
wristRollCON = cmds.rename(
self.pivotList[x], self.pivotList[x].replace('PIVOT', 'CON'))
# create spaceLocator
shoulderLOC = cmds.spaceLocator(
n=self.subIkJointList[1].replace('JNT', 'PV_LOC'))
shoulderLocatorNUL = homeNul(shoulderLOC[0])
Psnap(shoulderLocatorNUL, self.subIkJointList[1])
cmds.setAttr('%s.translateZ' % shoulderLOC[0], -5)
wristRollLOC = cmds.spaceLocator(
n=wristRollCONT.replace('CON', 'PV_LOC'))
wristRollLocatorNUL = homeNul(wristRollLOC[0])
cmds.parent(wristRollLocatorNUL, wristRollCONT)
Psnap(wristRollLocatorNUL, wristRollCONT)
cmds.setAttr('%s.translateZ' % wristRollLOC[0], -5)
# pole Vector Constrain
cmds.poleVectorConstraint(shoulderLOC, self.G_RPName)
cmds.poleVectorConstraint(elbowPVContollerName, self.RPsName)
cmds.poleVectorConstraint(wristRollLOC, self.RP1Name)
#
cmds.parentConstraint(self.subIkJointList[-2],
self.wristPivotNameNul,
mo=True)
cmds.setKeyframe('%s.rx' % self.wristPivotNameNul)
cmds.setKeyframe('%s.ry' % self.wristPivotNameNul)
cmds.setKeyframe('%s.rz' % self.wristPivotNameNul)
cmds.disconnectAttr('pairBlend1_inRotateX1.output',
'pairBlend1.inRotateX1')
cmds.disconnectAttr('pairBlend1_inRotateY1.output',
'pairBlend1.inRotateY1')
cmds.disconnectAttr('pairBlend1_inRotateZ1.output',
'pairBlend1.inRotateZ1')
cmds.delete('pairBlend1_inRotateX1', 'pairBlend1_inRotateY1',
'pairBlend1_inRotateZ1')
cmds.rename('pairBlend1', 'L_clvicleRotZ_PBD')
#
cmds.addAttr(wristRollCONT,
longName='wristRoll',
at='enum',
en='Lock',
keyable=True)
cmds.setAttr('%s.wristRoll' % wristRollCONT, lock=True)
cmds.addAttr(wristRollCONT,
longName='fallowRotate',
at='double',
keyable=True,
attributeType='float',
min=0,
max=1,
dv=1)
cmds.connectAttr('%s.fallowRotate' % wristRollCONT,
'%s.blendParent1' % self.wristPivotNameNul)
#cmds.connectAttr( '%s.vis' % haindLegControllerName, '%s.visibility' % self.pivotNulList[0] )
cmds.select(cl=True)
def createIkSpineController(self):
rootCon = fkControllerMaker('cross', 'yellow',
[self.spineJointList[0]])
spine1Con = fkControllerMaker('cube', 'yellow',
[self.spineJointList[1]])
chestCon = fkControllerMaker('cube', 'yellow',
[self.spineJointList[-1]])
self.spineControllerList = rootCon[0][0], spine1Con[0][0], chestCon[0][
0]
self.spineControllerNulList = rootCon[1][0], spine1Con[1][0], chestCon[
1][0]
self.spineConstraintList = rootCon[2][0], spine1Con[2][0], chestCon[2][
0]
cmds.delete(self.spineConstraintList)
"""
for each in range( len(self.spineControllerNulList)-1 ):
cmds.delete( cmds.aimConstraint( self.spineJointList[each+1], self.spineControllerNulList[each], aimVector=[0,1,0], upVector=[0,0,-1], worldUpType='vector', worldUpVector=[0,1,0] ) )
cmds.delete( cmds.aimConstraint( self.spineJointList[-2], self.spineControllerNulList[-1], aimVector=[0,-1,0], upVector=[0,0,-1], worldUpType='vector', worldUpVector=[0,1,0] ) )
"""
self.hipCon = controllerShape('C_IK_hip_CON', 'cube', 'yellow')
#print self.spineJointList[1]
POsnap(self.hipCon, self.spineJointList[0])
hipConNul = homeNul(self.hipCon)
"""
cmds.delete( cmds.aimConstraint( self.spineJointList[2], hipConNul, aimVector=[0,1,0], upVector=[0,0,-1], worldUpType='vector', worldUpVector=[0,1,0] ) )
"""
#cmds.parent( hipConNul, self.spineControllerList[1] )
# 'C_IK_hip_CON' pivot moving~~
lowBodyPos = cmds.xform(spine1Con[0], ws=True, t=True, q=True)
cmds.move(lowBodyPos[0], lowBodyPos[1], lowBodyPos[2],
'%s.rotatePivot' % self.hipCon)
cmds.move(lowBodyPos[0], lowBodyPos[1], lowBodyPos[2],
'%s.rotatePivot' % hipConNul)
hipConCvN = cmds.getAttr('%s.spans' % self.hipCon)
cmds.select('%s.cv[0:%s]' % (self.hipCon, hipConCvN))
cmds.scale(0.8, 0.8, 0.8, ocp=True)
cmds.select(cl=True)
# Add Sub Controller
print self.spineControllerNulList
self.lowBodySubCon = controllerShape('C_IK_lowBodySub_CON', 'cube',
'yellow')
self.upBodySubCon = controllerShape('C_IK_upBodySub_CON', 'cube',
'yellow')
lowBodySubConCvN = cmds.getAttr('%s.spans' % self.lowBodySubCon)
cmds.select('%s.cv[0:%s]' % (self.lowBodySubCon, lowBodySubConCvN))
cmds.scale(0.8, 0.8, 0.8, ocp=True)
cmds.select(cl=True)
upBodySubConCvN = cmds.getAttr('%s.spans' % self.upBodySubCon)
cmds.select('%s.cv[0:%s]' % (self.upBodySubCon, upBodySubConCvN))
cmds.scale(0.8, 0.8, 0.8, ocp=True)
cmds.select(cl=True)
self.lowBodySubConNul = homeNul(self.lowBodySubCon)
self.upBodySubConNul = homeNul(self.upBodySubCon)
POsnap(self.lowBodySubConNul, spine1Con[0][0])
POsnap(self.upBodySubConNul, chestCon[0][0])
cmds.parent(self.lowBodySubConNul, spine1Con[0][0])
cmds.parent(self.upBodySubConNul, chestCon[0][0])
cmds.parent(hipConNul, self.lowBodySubCon)
#........................................................................................
#print self.spineControllerList#(u'C_IK_root_CON', u'C_IK_spine1_CON', u'C_IK_chest_CON')
self.lowBody = cmds.rename(self.spineControllerList[1],
'C_IK_lowBody_CON')
self.upBody = cmds.rename(self.spineControllerList[2],
'C_IK_upBody_CON')
self.lowBodyNul = cmds.rename(self.spineControllerNulList[1],
'C_IK_lowBody_NUL')
self.upBodyNul = cmds.rename(self.spineControllerNulList[2],
'C_IK_upBody_NUL')
def createController(self):
# create controller
haindLegControllerName = controllerShape( self.IkHindLegJointList[3].replace( 'ball_JNT', 'hindLeg_CON' ), 'cube', 'blue' )
cmds.move( self.anklePos[0], self.anklePos[1], self.anklePos[2], haindLegControllerName )
hipControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'CON' ), 'cube', 'blue' )
POsnap( hipControllerName, self.IkHindLegJointList[0] )
hipWorldControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'world_CON' ), 'cube', 'blue' )
Psnap( hipWorldControllerName, self.IkHindLegJointList[0] )
kneePVContollerName = cmds.spaceLocator( n=self.IkHindLegJointList[1].replace( 'JNT', 'LOC' ) )[0]
kneePVPos = cmds.xform( self.IkHindLegJointList[0], t=True, ws=True, q=True )
cmds.move( kneePVPos[0], kneePVPos[1], kneePVPos[2] + 20, kneePVContollerName )
anklePVContollerName = controllerShape( self.IkHindLegJointList[2].replace( 'JNT', 'CON' ), 'sphere', 'blue' )
anklePVPos = cmds.xform( self.IkHindLegJointList[2], t=True, ws=True, q=True )
cmds.move( anklePVPos[0], anklePVPos[1], anklePVPos[2], anklePVContollerName )
# controller homeNull
homeNul( haindLegControllerName )
hipNul = homeNul( hipControllerName )
hipRotZNul = homeNul( hipControllerName, hipNul.replace( 'hip', 'hipRotZ' ) )
hipNulWorldNul = homeNul( hipWorldControllerName )
kneePVNul = homeNul( kneePVContollerName )
homeNul( anklePVContollerName )
# constraints & grouping
cmds.parent( self.pivotNulList[0], haindLegControllerName )
cmds.parent( kneePVNul, hipControllerName )
cmds.parent( hipNul, hipWorldControllerName )
if self.side != 'R' :
cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ 1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] )
else :
cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ -1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] )
cmds.pointConstraint( hipControllerName, self.IkHindLegJointList[0] )
cmds.pointConstraint( hipControllerName, self.subIkJointList[0] )
cmds.orientConstraint( hipControllerName, self.subIkJointList[0] )
cmds.poleVectorConstraint( anklePVContollerName, self.sRPsName )
cmds.poleVectorConstraint( kneePVContollerName, self.RPsName )
# addAttr & connection
cmds.addAttr( haindLegControllerName, longName='auto', at='enum', en='Angle', keyable=True )
cmds.setAttr( '%s.auto' % haindLegControllerName, lock=True )
cmds.addAttr( haindLegControllerName, longName='front', at='double', keyable=True, attributeType='float', min=0, max=1, dv=0.5 )
cmds.addAttr( haindLegControllerName, longName='subController', at='enum', en='Visibility', keyable=True )
cmds.setAttr( '%s.subController' % haindLegControllerName, lock=True )
cmds.addAttr( haindLegControllerName, longName='vis', at='bool', keyable=True )
cmds.setKeyframe( '%s.rz' % hipRotZNul )
cmds.disconnectAttr( 'pairBlend1_inRotateZ1.output', 'pairBlend1.inRotateZ1' )
cmds.delete( 'pairBlend1_inRotateZ1' )
cmds.rename( 'pairBlend1', hipRotZNul.replace( 'NUL', 'PBD' ) )
cmds.connectAttr ( '%s.front' % haindLegControllerName, '%s.blendAim1' % hipRotZNul )
# create foot controller
ankleRollCONT = controllerShape( self.anklePivotName.replace( 'PIVOT', 'CON' ), 'cube', 'yellow' )
cvNum = cmds.getAttr( '%s.spans' % ankleRollCONT ) + cmds.getAttr( '%s.degree' % ankleRollCONT )
cmds.select( '%s.cv[0:%s]' % ( ankleRollCONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % ankleRollCONT, self.anklePivotName, r=True, s=True )
cmds.delete( ankleRollCONT )
ankleRollCON = cmds.rename( self.anklePivotName, self.anklePivotName.replace( 'PIVOT', 'CON' ) )
for x in range( len( self.pivotList ) ):
CONT = controllerShape( self.pivotList[x].replace( 'PIVOT', 'CON' ), 'cube', 'yellow' )
cvNum = cmds.getAttr( '%s.spans' % CONT ) + cmds.getAttr( '%s.degree' % CONT )
cmds.select( '%s.cv[0:%s]' % ( CONT, cvNum-1 ) )
cmds.scale( 0.5, 0.5, 0.5 )
cmds.select( cl=True )
cmds.parent( '%sShape' % CONT, self.pivotList[x], r=True, s=True )
cmds.delete( CONT )
ankleRollCON = cmds.rename( self.pivotList[x], self.pivotList[x].replace( 'PIVOT', 'CON' ) )
cmds.connectAttr( '%s.vis' % haindLegControllerName, '%s.visibility' % self.pivotNulList[0] )
