def rigHeadCmd( prefix='head_', suffix='', hasStretch=True ):
exp_template = EXP_HEAD
labels = {
'control' : prefix + 'control' + suffix,
'aimControl' : prefix + 'aim' + suffix,
'ik' : prefix + 'ik' + suffix,
'ikEnd' : prefix + 'ik_end' + suffix,
'parent' : prefix + 'parent' + suffix,
'expression' : prefix + 'control' + suffix + '_EXP',
'parent' : prefix + 'parent' + suffix,
'pivot' : prefix + 'pivot' + suffix,
}
try:
start_joint = pm.ls(sl=1,type="joint")[0]
except ValueError:
raise ValueError, "Select the root joint to setup."
end_joint = start_joint.getChildren(type='joint')[0]
neck_joint = start_joint.getParent()
parent_joint = neck_joint.getParent()
if neck_joint is None:
raise ValueError, "Start joint must have a parent joint (neck)."
if parent_joint is None:
raise ValueError, "Start joint parent must have a parent transform (spine)."
unit_scale = start_joint.getRotatePivot(ws=1)[-1]
start_point = start_joint.getRotatePivot(ws=1) * unit_scale
end_point = end_joint.getRotatePivot(ws=1) * unit_scale
mid_point = ( start_point + end_point ) / 2
length = start_point.distanceTo( end_point )
aim_point = Vector( start_point[0], start_point[1], start_point[1])*100
# -- build controls
control = createNurbsShape( labels['control'], width=length, height=length*1.2, depth=length*1.1 )
control.translate.set( mid_point )
pm.makeIdentity( control, apply=True, t=1 )
control.rotatePivot.set( start_joint.getRotatePivot(ws=1) * unit_scale )
control.scalePivot.set( start_joint.getRotatePivot(ws=1) * unit_scale )
control.selectHandle.set( start_joint.getRotatePivot(ws=1) * unit_scale )
control.addAttr( "ikBlend", at='double', k=1, dv=0, min=0, max=1 )
control.addAttr( "aimBlend", at='double', k=1, dv=0, min=0, max=1 )
# -- build aim control
aim_control = createNurbsShape( labels['aimControl'], 'arrow', size=length/1.5 )
aim_control.translate.set( aim_point )
pm.makeIdentity( aim_control, apply=True, t=1 )
pm.aimConstraint( start_joint, aim_control, weight=1, aimVector=(0, 0, 1) )
# -- Create Aim Line
aim_line = pm.curve( name=labels['aimControl']+'_line', d=1, p=[aim_point, mid_point], k=[0, 1] )
line_cluster0, line_handle0 = pm.cluster( aim_line+'.cv[0]', n=labels['aimControl']+'_line_0', en=1, rel=1 )
line_cluster1, line_handle1 = pm.cluster( aim_line+'.cv[1]', n=labels['aimControl']+'_line_1', en=1, rel=1 )
pm.pointConstraint( aim_control, line_handle0, offset=(0,0,0), weight=1 )
pm.pointConstraint( start_joint, line_handle1, offset=(0,0,0), weight=1 )
line_group0 = pm.group( line_handle0, name=line_handle0.name() + "_grp" )
line_group1 = pm.group( line_handle1, name=line_handle0.name() + "_grp" )
pm.parent( [aim_line,
line_group0,
line_group1,
aim_control] )
line_group0.v.set(0)
line_group1.v.set(0)
setAttrs( line_group0, ['t','r','s','v'], lock=1 )
setAttrs( line_group1, ['t','r','s','v'], lock=1 )
setAttrs( aim_line, ['t','r','s','v'], lock=1 )
aim_line.overrideEnabled.set(1)
aim_line.overrideDisplayType.set(1)
# -- build helper groups
pivot_grp = pm.group( n=labels['pivot'], em=1 )
parent_grp = pm.group( pivot_grp, n=labels['parent'] )
parent_grp.translate.set( control.getRotatePivot(ws=1) * unit_scale )
pm.makeIdentity( parent_grp, apply=True, t=1 )
pivot_grp.rotateOrder.set(2)
# -- create ik handles
main_ik, main_ee = pm.ikHandle( n=labels['ik'], sj=neck_joint, ee=end_joint, sol='ikRPsolver', dh=1 )
#main_ik, main_ee = pm.ikHandle( n=labels['ik'], sj=neck_joint, ee=start_joint, sol='ikRPsolver', dh=1 )
#end_ik, end_ee = pm.ikHandle( n=labels['ikEnd'], sj=start_joint, ee=end_joint, sol='ikSCsolver', dh=1 )
pm.parent( main_ik, control )
pm.parent( control, pivot_grp )
# -- set up constraints
#pm.aimConstraint( control, aim_control, weight=1, aimVector=(0, 0, -1), mo=1 )
pm.aimConstraint( aim_control, pivot_grp, weight=1, aimVector=(0, 0, 1), mo=1 )
pm.setKeyframe( pivot_grp.r )
pm.parentConstraint( parent_joint, parent_grp, weight=1, mo=1 )
resetIkSetupCmd(start_joint, control)
resetIkSetupCmd(start_joint, aim_control)
exp_str = exp_template \
% { 'control' : control,
'start_joint' : start_joint,
'end_joint' : end_joint,
'parent_joint' : parent_joint,
'main_ik' : main_ik,
#'end_ik' : end_ik,
'pivot' : pivot_grp,
'shape' : control.getShape(),
}
pm.expression( s=exp_str, o=control, n=labels['expression'], a=1, uc='all' )
# -- make things look pretty
for n in pm.ls( [main_ik], dag=1, type="transform" ):
n.visibility.set(0)
control.displayHandle.set(1)
addToSet( [control, aim_control], 'controlsSet' )
setAttrs( control, ['sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
setAttrs( aim_control, ['rx','ry','rz','sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
pm.setAttr(control.v, keyable=0 )
pm.setAttr(aim_control.v, keyable=0 )
pm.select( [control,aim_control], r=1 )
pm.color( ud=CntlColors.head )
return [ control, aim_control ]
def rigLimbCmd( prefix='leg_', suffix=None, side=LEFT_SIDE, hasStretch=False, hasFootRoll=False, footRollMode=FOOTROLL_AUTO ):
suffix = suffix or ('_l','_r')[side]
exp_template = ""
labels = {
'control' : prefix + 'control' + suffix,
'aimControl' : prefix + 'aim' + suffix,
'ik' : prefix + 'ik' + suffix,
'ikEnd' : prefix + 'ik_end' + suffix,
'expression' : prefix + 'control' + suffix + '_EXP',
'guideJointIk' : prefix + 'ik_guide_',
'guideJoint' : prefix + 'guide_',
'ikStretch' : prefix + 'ik_stretch' + suffix,
'locStart' : prefix + 'loc_start' + suffix,
'locMid' : prefix + 'loc_mid' + suffix,
'locEnd' : prefix + 'loc_end' + suffix,
'locGuide' : prefix + 'loc_guide' + suffix,
'ikGuide' : prefix + 'ik_guide' + suffix,
}
try:
start_joint, end_joint = pm.ls(sl=1,type="joint")
except ValueError:
raise ValueError, "Select the start and end joints to setup."
mid_joint = end_joint.getParent()
parent_joint = start_joint.getParent()
unit_scale = start_joint.getRotatePivot(ws=1)[-1]
# -- positions and length
start_point = start_joint.getRotatePivot(ws=1) * unit_scale
end_point = end_joint.getRotatePivot(ws=1) * unit_scale
mid_point = mid_joint.getRotatePivot(ws=1) * unit_scale
length = start_point.distanceTo( end_point )
# -- Create Control
control = createNurbsShape( labels['control'], 'sphere', size=length*.2 )
control2 = createNurbsShape( labels['control'], 'locator', size=length*.3 )
pm.parent( control2.getShape(), control, r=1, s=1 )
pm.delete( control2 )
control.translate.set( end_point )
pm.makeIdentity( control, apply=True, s=0, r=0, t=1, n=0 )
control.addAttr( "ikBlend", at='double', k=1, dv=0, min=0, max=1 )
control.addAttr( "orientBlend", at='double', k=1, dv=0, min=0, max=1 )
# -- Create Aim Control
v1 = end_point - start_point
v2 = mid_point - start_point
v3 = v1.cross( v2 )
v4 = v3.cross( v1 )
aim_point = start_point + ( v4.normal() * length * 1.5 )
aim_control = createNurbsShape( labels['aimControl'], 'arrow', size=length/5 )
pm.xform( aim_control, t=aim_point )
pm.makeIdentity( apply=True, s=0, r=0, t=1, n=0 )
pm.aimConstraint( mid_joint, aim_control, weight=1, aimVector=(0, 0, 1) )
# -- Create Aim Line
aim_line = pm.curve( name=labels['aimControl']+'_line', d=1, p=[aim_point, mid_point], k=[0, 1] )
line_cluster0, line_handle0 = pm.cluster( aim_line+'.cv[0]', n=labels['aimControl']+'_line_0', en=1, rel=1 )
line_cluster1, line_handle1 = pm.cluster( aim_line+'.cv[1]', n=labels['aimControl']+'_line_1', en=1, rel=1 )
pm.pointConstraint( aim_control, line_handle0, offset=(0,0,0), weight=1 )
pm.pointConstraint( mid_joint, line_handle1, offset=(0,0,0), weight=1 )
line_group0 = pm.group( line_handle0, name=line_handle0.name() + "_grp" )
line_group1 = pm.group( line_handle1, name=line_handle0.name() + "_grp" )
pm.parent( [aim_line,
line_group0,
line_group1,
aim_control] )
line_group0.v.set(0)
line_group1.v.set(0)
setAttrs( line_group0, ['t','r','s','v'], lock=1 )
setAttrs( line_group1, ['t','r','s','v'], lock=1 )
setAttrs( aim_line, ['t','r','s','v'], lock=1 )
aim_line.overrideEnabled.set(1)
aim_line.overrideDisplayType.set(1)
if hasStretch:
guide_ik_start = pm.duplicate( start_joint, rc=1 )[0]
guide_ik_mid, guide_ik_end = pm.ls( guide_ik_start, dag=1 )[1:3]
for n in pm.ls( guide_ik_start, dag=1 ):
pm.rename( n, labels['guideJointIk'] + n[:-1] )
guide_start = pm.duplicate( start_joint, rc=1 )[0]
guide_mid, guide_end = pm.ls( guide_start, dag=1 )[1:3]
for n in pm.ls( guide_start, dag=1 ):
pm.rename( n, labels['guideJoint'] + n[:-1] )
parent_group = pm.group( name=labels['ikStretch'], em=1 )
if parent_joint is not None:
parent_group.setRotatePivot( parent_joint.getRotatePivot(ws=1) * unit_scale, ws=1 )
pm.parentConstraint( parent_joint, parent_group, weight=1 )
pm.parent( guide_ik_start, guide_start, parent_group )
# -- build a temp joint chain to get loc_mid position
loc_start = pm.group( n=labels['locStart'], em=1 )
pm.parent( loc_start, parent_group )
loc_start.setRotatePivot( start_joint.getRotatePivot( ws=1) * unit_scale, ws=1 )
pm.aimConstraint( control, loc_start, weight=1, aimVector=(1,0,0) )
loc_end = pm.group( n=labels['locEnd'], em=1, parent=loc_start )
loc_end.setRotatePivot( start_joint.getRotatePivot( ws=1) * unit_scale, ws=1 )
pm.pointConstraint( control, loc_end, offset=(0,0,0), skip=('y','z'), weight=1 )
pm.select(cl=1)
temp_start = pm.joint( p=start_point )
temp_end = pm.joint( p=end_point )
pm.joint( temp_start, edit=1, oj='xyz', secondaryAxisOrient='yup', ch=1 )
pm.pointConstraint( mid_joint, temp_end, offset=(0,0,0), skip=('y','z'), weight=1 )
loc_mid_point = temp_end.getRotatePivot(ws=1) * unit_scale
pm.delete( temp_start )
# -- create the mid locator
loc_mid = pm.group( n=labels['locMid'], em=1)#spaceLocator()
loc_mid.translate.set( loc_mid_point )
pm.makeIdentity( apply=True, s=0, r=0, t=1, n=0 )
pm.pointConstraint( loc_start, loc_mid, mo=1, weight=1 )
pm.pointConstraint( loc_end, loc_mid, mo=1, weight=1 )
# -- create the guide locator
loc_guide = pm.group( n=labels['locGuide'], em=1)
guide_constraint = pm.pointConstraint( loc_mid, loc_guide, offset=(0,0,0), weight=1 )
pm.pointConstraint( guide_ik_mid, loc_guide, offset=(0,0,0), weight=1 )
pm.parent( loc_mid, loc_guide, parent_group )
guide_ik, guide_ee = pm.ikHandle( sj=guide_ik_start, ee=guide_ik_end, solver="ikRPsolver", dh=1 )
pm.poleVectorConstraint( aim_control, guide_ik, weight=1 )
pm.delete( guide_ik_end )
pm.rename( guide_ik, labels['ikGuide'] )
# -- SET STRETCH BLEND START
guide_ik.addAttr( "stretchStart", at='double', k=1 )
guide_ik.stretchStart.set( loc_end.tx.get() )
# -- SET STRETCH BLEND END
guide_ik.addAttr( "stretchEnd", at='double', k=1 )
guide_ik.stretchEnd.set( loc_end.tx.get()*1.1 )
# -- SET STRETCH BLEND END
guide_ik.addAttr( "stretchFactor", at='double', k=1 )
guide_ik.stretchFactor.set( 0.22 )
# -- setup guide joints
pm.aimConstraint( loc_guide, guide_start, weight=1, aimVector=(1,0,0) )
pm.aimConstraint( loc_end, guide_mid, weight=1, aimVector=(1,0,0) )
pm.pointConstraint( loc_guide, guide_mid, offset=(0,0,0), skip=('y','z'), weight=1 )
pm.pointConstraint( loc_end, guide_end, offset=(0,0,0), skip=('y','z'), weight=1 )
pm.parent( guide_ik, loc_end )
pm.parent( guide_ik, control )
# -- add stretch addtributes
start_joint.addAttr( "stretch", at='double', k=1, dv=0 )
mid_joint.addAttr( "stretch", at='double', k=1, dv=0 )
control.addAttr( "stretchBlend", at='double', k=1, dv=0, min=0, max=1 )
# -- build the expression
exp_template += EXP_STRETCH \
% { 'guide_ik' : guide_ik,
'loc_end' : loc_end,
'constraint' : guide_constraint,
# -- we only need these names for the constraint attribute names
'guide_ik_mid' : guide_ik_mid.split('|')[-1],
'loc_mid' : loc_mid.split('|')[-1],
'control' : control,
'start_joint' : start_joint,
'mid_joint' : mid_joint,
'end_joint' : end_joint,
'guide_mid' : guide_mid,
'guide_end' : guide_end,
}
# -- make things look pretty
for n in pm.ls( [ parent_group, guide_ik ], dag=1 ):
n.visibility.set(0)
for obj in guide_end.getChildren( type='joint' ):
try:
pm.delete( obj )
except:
pass
# -- hook up the original joints
main_ik, main_ee = pm.ikHandle( sj=start_joint, ee=end_joint, solver="ikRPsolver", dh=1 )
pm.poleVectorConstraint( aim_control, main_ik, weight=1 )
pm.rename( main_ik, labels['ik'] )
end_ik, end_ee = pm.ikHandle( sj=end_joint, ee=end_joint.getChildren(type='joint')[0], solver="ikRPsolver", dh=1 )
pm.rename( end_ik, labels['ikEnd'] )
pm.parent( main_ik, end_ik, control )
# -- fill out the expression template
exp_template += EXP_IKFK + EXP_VIS
exp_str = exp_template \
% {
#'guide_ik' : guide_ik,
#'loc_end' : loc_end,
#'constraint' : guide_constraint,
#we only need these names for the constraint attribute names
#'guide_ik_mid' : guide_ik_mid.split('|')[-1],
#'loc_mid' : loc_mid.split('|')[-1],
'control' : control,
'start_joint' : start_joint,
'mid_joint' : mid_joint,
'end_joint' : end_joint,
#'guide_mid' : guide_mid,
#'guide_end' : guide_end,
'main_ik' : main_ik,
'end_ik' : end_ik,
'shape1' : control.getChildren(type="nurbsCurve")[0],
'shape2' : control.getChildren(type="nurbsCurve")[1],
}
pm.expression( s=exp_str, o=control, n=labels['expression'], a=1, uc='all' )
if hasFootRoll:
rigFootRoll( end_joint, control, prefix, suffix, side=side, footRollMode=footRollMode )
resetIkSetupCmd(end_joint, control)
resetIkSetupCmd(start_joint, aim_control)
# -- make things look pretty
for n in pm.ls( control, dag=1, type="transform" )[1:]:
if n.type() != "transform":
n.visibility.set(0)
setAttrs( control, ['sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
setAttrs( aim_control, ['rx','ry','rz','sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
pm.setAttr(control.v, keyable=0 )
pm.setAttr(aim_control.v, keyable=0 )
addToSet( [control, aim_control], 'controlsSet' )
pm.select( [control, aim_control], r=1 )
pm.color( ud=(CntlColors.left, CntlColors.right)[side] )
control.displayHandle.set(1)
pm.select( control, r=1 )
pm.reorder( control.getShape(), back=1 )
return [ control, aim_control ]
def rigSpineCmd( prefix='spine_', suffix='', hasStretch=False, worldSpace=False ):
exp_template = ''
labels = {
'end_control' : prefix + 'control_end' + suffix,
'mid_control' : prefix + 'control_mid' + suffix,
'ik' : prefix + 'ik' + suffix,
'curve' : prefix + 'curve' + suffix,
'cluster' : prefix + 'cluster' + suffix,
'clusters' : prefix + 'clusters' + suffix,
'parent' : prefix + 'parent' + suffix,
'expression' : prefix + 'controls' + suffix + '_EXP',
}
try:
start_joint, end_joint = pm.ls(sl=1,type="joint")
except ValueError:
raise ValueError, "Select the start and end joints to setup."
parent_joint = start_joint.getParent()
mid_joint = start_joint.getChildren(type='joint')[0]
if parent_joint is None:
raise ValueError, "Start joint must have a parent transform."
main_ik, main_ee, main_curve = pm.ikHandle( n=labels['ik'],
sj=start_joint,
ee=end_joint,
sol='ikSplineSolver',
pcv=True,
numSpans=1,
dh=1
)
main_curve.rename( labels['curve'] )
cluster0, handle0 = pm.cluster( main_curve+'.cv[0]', main_curve+'.cv[1]',
n=labels['cluster']+'0', en=1, rel=1
)
cluster1, handle1 = pm.cluster( main_curve+'.cv[1]', main_curve+'.cv[2]',
n=labels['cluster']+'1', en=1, rel=1
)
cluster2, handle2 = pm.cluster( main_curve+'.cv[4]',
n=labels['cluster']+'2', en=1, rel=1
)
start_point = start_joint.getRotatePivot(ws=1) * start_joint.getRotatePivot(ws=1)[-1]
end_point = end_joint.getRotatePivot(ws=1) * end_joint.getRotatePivot(ws=1)[-1]
handle1_point = handle1.getRotatePivot(ws=1) * handle1.getRotatePivot(ws=1)[-1]
length = start_point.distanceTo( end_point )
# -- build controls
control = pm.circle( n=labels['end_control'], radius=(length / 2), normal=(0,1,0), ch=0 )[0]
control.translate.set( end_point )
control.rotateOrder.set(1)
mid_control = pm.circle( n=labels['mid_control'], radius=(length / 2), normal=(0,1,0), ch=0 )[0]
mid_control.translate.set( handle1_point )
pm.makeIdentity( [ control, mid_control ], apply=True, s=0, r=0, t=1, n=0 )
# -- add control attributes
control.addAttr( "ikBlend", at='double', k=1, dv=0, min=0, max=1 )
# -- constrain controls
pm.pointConstraint( control, handle2, offset=(0,0,0), weight=1 )
pm.aimConstraint( handle1, control, weight=1, aimVector=(0,-1,0), skip='y' )
pm.pointConstraint( mid_control, handle1, offset=(0,0,0), weight=1 )
pm.aimConstraint( handle0, mid_control, weight=1, aimVector=(0,1,0) )
if worldSpace:
pm.pointConstraint( parent_joint, handle0, maintainOffset=1, weight=1 )
# -- group and parent nodes
cluster_group = pm.group( handle0, handle1, handle2, name=labels['clusters'] )
parent_group = pm.group( name=labels['parent'], em=1 )
parent_group.rotatePivot.set( parent_joint.getRotatePivot(ws=1) )
pm.parent( control, mid_control, main_ik, main_curve, cluster_group, parent_group )
if not worldSpace:
pm.parentConstraint( parent_joint, parent_group, w=1, mo=1 )
if hasStretch:
control.addAttr( "stretch", at='double', k=1, dv=0, min=-1, max=1 )
exp_template += EXP_SPINE_STRETCH
exp_template += EXP_SPINE
exp_str = exp_template \
% { 'control' : control,
'start_joint' : start_joint,
'end_joint' : end_joint,
'mid_joint' : mid_joint,
'parent_joint' : parent_joint,
'main_ik' : main_ik,
'shape' : control.getShape(),
'mid_shape' : mid_control.getShape(),
}
pm.expression( s=exp_str, o=control, n=labels['expression'], a=1, uc='all' )
resetIkSetupCmd(end_joint, control)
# -- make things look pretty
for n in pm.ls( [main_ik, main_curve, cluster_group], dag=1, type="transform" ):
n.visibility.set(0)
addToSet( [control, mid_control], 'controlsSet' )
control.displayHandle.set(1)
setAttrs( control, ['rx','rz','sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
setAttrs( mid_control, ['rx','ry','rz','sx','sy','sz'], channelBox=0, keyable=0, lock=1 )
pm.setAttr(control.v, keyable=0 )
pm.setAttr(mid_control.v, keyable=0 )
pm.color( ud=CntlColors.center )
pm.select( control, r=1 )
return [ control, mid_control ]
