def create_controller(self):
self.controller = pm.curve(
name=self.controller,
d=3,
periodic=2,
k=(-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
point=((0, 0.4, 0.25), (0, 0.4, 0.4), (0, 0.25, 0.4),
(0, -0.25, 0.4), (0, -0.4, 0.4), (0, -0.4, 0.25),
(0, -0.4, -0.25), (0, -0.4, -0.4), (0, -0.25, -0.4),
(0, 0.25, -0.4), (0, 0.4, -0.4), (0, 0.4, -0.25),
(0, 0.4, 0.25), (0, 0.4, 0.4), (0, 0.25, 0.4)))
for axis in ['X', 'Y', 'Z']:
pm.setAttr('{}.rotate{}'.format(self.controller, axis),
keyable=False)
pm.setAttr('{}.scale{}'.format(self.controller, axis),
keyable=False)
pm.setAttr('{}.translate{}'.format(self.controller, axis),
keyable=False)
self.controller.translateX.lock()
self.controller.translateY.showInChannelBox(True)
self.controller.translateZ.showInChannelBox(True)
self.controller.rotate.lock()
self.controller.scale.lock()
self.controller.visibility.setKeyable(False)
self.controller.visibility.lock()
pm.transformLimits(self.controller, tx=(0, 0), ty=(0, 0), tz=(0, 0))
pm.transformLimits(self.controller,
etx=(False, False),
ety=(True, True),
etz=(True, True))
def build_upper_halfbox(type, label=[], connections=True):
if not pm.objExists(type + "_Prnt"):
mainDict = {}
squareShape = [[-1.0, 1.0, 0.0],
[-1.0, 0.0043876273513161479, 0.0],
[1.0, 0.0043876273513161479, 0.0],
[1.0, 1.0, 0.0],
[-1.0, 1.0, 0.0]]
box = pm.curve(d=1, p=squareShape, n=type + "_Prnt")
boxShape = box.getShape()
boxShape.overrideEnabled.set(1)
boxShape.overrideDisplayType.set(1)
ctrl = pm.circle(nr=[0, 0, 0], r=0.2, ch=0, n=type + "_Ctrl")[0]
pm.parent(ctrl, box)
pm.transformLimits(ctrl, tx=[-1, 1], etx=[1, 1], ety=[1, 1], ty=[0, 1])
libUtilities.lockAttr(str(ctrl), ["tz", "rx", "ry", "rz", "sx", "sy", "sz", "v"])
mainDict["border"] = box
mainDict["ctrl"] = ctrl
if connections:
connect_dict = {}
connect_dict["TopLeftCorner"] = build_left_top_corner(type, ctrl)
connect_dict["TopRightCorner"] = build_right_top_corner(type, ctrl)
mainDict["connections"] = connect_dict
if label:
mainDict["label"] = build_label(label, box)
return mainDict
else:
raise Exception(type + " setup already exists")
def build_y_halfbox(type, label=[]):
if not pm.objExists(type + "_Prnt"):
mainDict = {}
squareShape = [[-0.112423266524, 1.0, 0.0],
[-0.112423266524, -1.0, 0.0],
[0.112423266524, -1.0, 0.0],
[0.112, 1.0, 0.0],
[-0.112423266524, 1.0, 0.0]]
box = pm.curve(d=1, p=squareShape, n=type + "_Prnt")
boxShape = box.getShape()
boxShape.overrideEnabled.set(1)
boxShape.overrideDisplayType.set(1)
ctrl = pm.circle(nr=[0, 0, 0], r=0.2, ch=0, n=type + "_Ctrl")[0]
pm.parent(ctrl, box)
pm.transformLimits(ctrl, tx=[0, 0], etx=[1, 1], ety=[1, 1], ty=[-1, 1])
libUtilities.lockAttr(str(ctrl), ["tz", "tx", "rx", "ry", "rz", "sx", "sy", "sz", "v"])
mainDict["border"] = box
mainDict["ctrl"] = ctrl
if label:
mainDict["label"] = build_label(label, box)
return mainDict
else:
raise Exception(type + " setup already exists")
def addObjects(self):
"""Add all the objects needed to create the component."""
t = self.guide.tra["root"]
if self.settings["mirrorBehaviour"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
# The border needs to fit the ctl range of motion
size = self.settings["ctlSize"]
minX = -1 if self.settings["tx_negative"] else 0
maxX = 1 if self.settings["tx_positive"] else 0
minY = -1 if self.settings["ty_negative"] else 0
maxY = 1 if self.settings["ty_positive"] else 0
margin = 0.1 * self.size
border_offset = dt.Point(minX + maxX, minY + maxY) * 0.5
self.border = self.addCtl(self.root,
"border",
t,
self.color_ik,
"square",
w=size + (maxX - minX) + margin,
d=size + (maxY - minY) + margin,
tp=self.parentCtlTag,
po=border_offset,
ro=dt.Vector(math.radians(90), 0, 0))
border_shape = self.border.getShape()
border_shape.overrideDisplayType.set(2) # Set display to reference
self.ctl = self.addCtl(self.border,
"ctl",
t,
self.color_ik,
self.settings["icon"],
d=size,
h=size,
w=size,
tp=self.parentCtlTag,
ro=dt.Vector(math.radians(90), 0, 0))
self.border.scale.set([self.size, self.size, self.size])
params = [
s for s in ["tx", "ty"]
if self.settings[s + "_negative"] or self.settings[s + "_positive"]
]
attribute.setKeyableAttributes(self.ctl, params)
attribute.setKeyableAttributes(self.border, [])
tx_limit = [minX, maxX]
ty_limit = [minY, maxY]
pm.transformLimits(self.ctl, tx=tx_limit, etx=[1, 1])
pm.transformLimits(self.ctl, ty=ty_limit, ety=[1, 1])
def toggle_limits(axis, controls=None):
"""
Toggles the controller translate Limits On or Off
from their current values, both upper and lower.
Aruments:
axis (str): x,y,z axis to use.
controls (list / optional): List of PyNodes to iterate over
If None, use Selection
"""
# If no controls are provided, use selection
if not controls:
controls = pm.ls(sl=True, type="transform")
# Loop over controls and toggle the limits
for control in controls:
if axis == "x":
current_status = pm.transformLimits(control, q=True, etx=True)
current_status_inv = [not i for i in current_status]
pm.transformLimits(control, etx=current_status_inv)
elif axis == "y":
current_status = pm.transformLimits(control, q=True, ety=True)
current_status_inv = [not i for i in current_status]
pm.transformLimits(control, ety=current_status_inv)
elif axis == "z":
current_status = pm.transformLimits(control, q=True, etz=True)
current_status_inv = [not i for i in current_status]
pm.transformLimits(control, etz=current_status_inv)
def fourWayShapeControl(driver,
shapes,
parent,
mult=0.5,
ctrlSize=1,
facialLoc='facialShapeDriver_LOC',
**kwds):
negPos = defaultReturn(-1, 'negPos', param=kwds)
ctrlSizeHalf = [ctrlSize / 2.0, ctrlSize / 2.0, ctrlSize / 2.0]
ctrlSizeQuarter = [ctrlSize / 4.0, ctrlSize / 4.0, ctrlSize / 4.0]
ctrlSize = [ctrlSize, ctrlSize, ctrlSize]
side = rig_nameGetSide(driver)
base = rig_nameGetBase(driver)
driverCtrl = rig_control(side=side,
name=base,
shape='pyramid',
modify=1,
lockHideAttrs=['rx', 'ry', 'rz', 'tx'],
scale=ctrlSizeQuarter)
pm.scale(driverCtrl.ctrl.cv, 1, 0, 1)
pm.delete(pm.parentConstraint(driver, driverCtrl.offset))
#pm.parentConstraint(parent, driverCtrl.offset, mo=True)
pm.parent(driverCtrl.offset, parent)
rig_animDrivenKey(driverCtrl.ctrl.translateY, (0, 1),
facialLoc + '.' + shapes[0], (0, 1))
rig_animDrivenKey(driverCtrl.ctrl.translateY, (0, -1),
facialLoc + '.' + shapes[1], (0, 1))
rig_animDrivenKey(driverCtrl.ctrl.translateZ, (0, 1),
facialLoc + '.' + shapes[2], (0, 1))
rig_animDrivenKey(driverCtrl.ctrl.translateZ, (0, -1),
facialLoc + '.' + shapes[3], (0, 1))
multiplyDivideNode(
side + base,
'multiply',
input1=[driverCtrl.ctrl.translateY, driverCtrl.ctrl.translateZ, 0],
input2=[negPos * mult, negPos * mult, negPos * mult],
output=[
driverCtrl.modify + '.translateY',
driverCtrl.modify + '.translateZ'
])
pm.transformLimits(driverCtrl.ctrl, ty=(-1, 1), ety=(1, 1))
pm.transformLimits(driverCtrl.ctrl, tz=(-1, 1), etz=(1, 1))
return driverCtrl
def create_camera_space_locator(frustum_curve):
"""Creates a locator under the given frame_curve
:param frustum_curve:
:return:
"""
# create the locator
locator = pm.spaceLocator()
locator_shape = locator.getShape()
pm.parent(locator, frustum_curve, r=True)
locator.tz.set(lock=True, keyable=False)
locator.rx.set(lock=True, keyable=False)
locator.ry.set(lock=True, keyable=False)
locator.rz.set(lock=True, keyable=False)
pm.transformLimits(locator, tx=(-0.5, 0.5), etx=(True, True))
pm.transformLimits(locator, ty=(-0.5, 0.5), ety=(True, True))
locator_shape.localScaleZ.set(0)
return locator
def create_camera_space_locator(frustum_curve):
"""Creates a locator under the given frame_curve
:param frustum_curve:
:return:
"""
# create the locator
locator = pm.spaceLocator()
locator_shape = locator.getShape()
pm.parent(locator, frustum_curve, r=True)
locator.tz.set(lock=True, keyable=False)
locator.rx.set(lock=True, keyable=False)
locator.ry.set(lock=True, keyable=False)
locator.rz.set(lock=True, keyable=False)
pm.transformLimits(locator, tx=(-0.5, 0.5), etx=(True, True))
pm.transformLimits(locator, ty=(-0.5, 0.5), ety=(True, True))
locator_shape.localScaleZ.set(0)
return locator
def snapToGround(self, *args):
groundPlaneObject = pm.textFieldButtonGrp(
self.widgets['groundplaneTextField'], q=True, tx=True)
list = pm.ls(sl=True, tr=True)
for x in list:
locator = pm.spaceLocator()
group = pm.group(locator)
pm.delete(pm.parentConstraint(x, group, mo=False))
Xparent = x.getParent()
pm.parent(x, locator)
pm.transformLimits(locator, tx=[0, 0], etx=[1, 1])
pm.transformLimits(locator, tz=[0, 0], etz=[1, 1])
pm.delete(pm.geometryConstraint(groundPlaneObject, locator, w=1))
pm.parent(x, Xparent)
pm.delete(group)
def createEasySmooth():
sel = pm.selected()
objs = sel[0:]
cruveGen = generateCurve(sel[-1])
slider = cruveGen[0]
sliderField = cruveGen[1]
smoothCtls = [cruveGen[2]]
ctl = sliderField
for currentSel in (sel[:-1]):
smoothCtls.append(generateChildCurve(currentSel))
pm.group(smoothCtls, n=smoothCtls[0] + '_Group')
# ctl = sel[-1] #[-1]で要素の末尾を取得
#新しいアトリビュートを作成する
pm.addAttr(ctl, ln='divisions', nn='div', at='long', min=0, max=4, dv=0)
#作成したアトリビュートの編集を有効可する
ctlDiv = pm.Attribute(ctl + '.divisions')
pm.setAttr(
ctlDiv,
e=True,
keyable=True,
)
for obj in objs:
smthChk = False
for cnct in set(obj.getShape().inputs()):
if isinstance(
cnct, pm.nt.PolySmoothFace
): #セットでinputsノードの重複を無くし、cnctの方がpolysmoothfaceだった場合（すでにスムースノードがある場合）はsmthckをtrueにする
smthChk = True
break
if smthChk:
ctlDiv >> cnct.divisions #すでにスムースノードがある場合は、それをctlDivアトリビュートと接続
else:
smthNode = pm.polySmooth(obj) #objに新しくスムースを追加し
ctlDiv >> smthNode[
0].divisions #スムースノードのdivisionsアトリビュートとctlのdivisionアトリビュート(ctlDiv)をつなぐ
pm.transformLimits(slider, tx=(0, 1.23), etx=(True, True))
pm.setDrivenKeyframe("%s.divisions" % ctl, cd="%s.tx" % slider, dv=0, v=0)
pm.setDrivenKeyframe("%s.divisions" % ctl,
cd="%s.tx" % slider,
dv=1.23,
v=4)
def build_face_x_control(type, connections=True):
if not pm.objExists(type + "_Prnt"):
mainDict = {}
prnt = pm.createNode("transform", n=type + "_Prnt")
ctrl = pm.curve(d=1, p=sphereShape, n=type + "_Ctrl")
pm.parent(ctrl, prnt)
pm.transformLimits(ctrl, tx=[-1, 1], etx=[1, 1])
libUtilities.lockAttr(str(ctrl), ["ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz", "v"])
mainDict["prnt"] = prnt
mainDict["ctrl"] = ctrl
if connections:
connect_dict = {}
connect_dict["RightCorner"] = build_right_corner(type, ctrl)
connect_dict["LeftCorner"] = build_left_corner(type, ctrl)
mainDict["connections"] = connect_dict
return mainDict
else:
raise Exception(type + " setup already exists")
def buildCockle(self):
self.main_grp = pmc.group(empty=1, name='%s_GRP' % self.name)
if not self.settingsNode:
self.settingsNode = self.main_grp
self.lf_grp = coreUtils.addChild(self.main_grp,
'group',
name='%s_lf_ZERO' % self.name)
coreUtils.align(self.lf_grp, self.lf_GD)
self.lf_drv = coreUtils.addChild(self.lf_grp,
'group',
name='%s_lf_DRV' % self.name)
pmc.transformLimits(self.lf_drv, rz=(0, 0), erz=(0, 1))
self.rt_grp = coreUtils.addChild(self.lf_drv,
'group',
name='%s_rt_ZERO' % self.name)
coreUtils.align(self.rt_grp, self.rt_GD)
self.rt_drv = coreUtils.addChild(self.rt_grp,
'group',
name='%s_rt_DRV' % self.name)
pmc.transformLimits(self.rt_drv, rz=(0, 0), erz=(1, 0))
self.fnt_grp = coreUtils.addChild(self.rt_drv,
'group',
name='%s_fnt_ZERO' % self.name)
coreUtils.align(self.fnt_grp, self.fnt_GD)
self.fnt_drv = coreUtils.addChild(self.fnt_grp,
'group',
name='%s_fnt_DRV' % self.name)
pmc.transformLimits(self.fnt_drv, rx=(0, 0), erx=(1, 0))
self.bck_grp = coreUtils.addChild(self.fnt_drv,
'group',
name='%s_bck_ZERO' % self.name)
coreUtils.align(self.bck_grp, self.bck_GD)
self.bck_drv = coreUtils.addChild(self.bck_grp,
'group',
name='%s_bck_DRV' % self.name)
pmc.transformLimits(self.bck_drv, rx=(0, 0), erx=(0, 1))
pmc.addAttr(self.settingsNode, ln='side_tilt', at='double', k=1, h=0)
pmc.addAttr(self.settingsNode, ln='front_tilt', at='double', k=1, h=0)
self.settingsNode.side_tilt.connect(self.lf_drv.rz)
self.settingsNode.side_tilt.connect(self.rt_drv.rz)
self.settingsNode.front_tilt.connect(self.fnt_drv.rx)
self.settingsNode.front_tilt.connect(self.bck_drv.rx)
pmc.delete([self.lf_GD, self.rt_GD, self.fnt_GD, self.bck_GD])
def camera_film_offset_tool():
"""Adds a locator to the selected camera with which you can adjust the 2d
pan and zoom.
Usage :
-------
- To add it, select the camera and use camera_film_offset_tool
- To remove it, set the transformations to 0 0 1 and then simply delete
the curve
- You can also use the ``enable`` option to temporarily disable the effect
"""
camera_shape = get_selected_camera()
if not camera_shape:
raise RuntimeError("please select one camera!")
# get the camera transform node
camera_transform = camera_shape.getParent()
frustum_curve = create_frustum_curve(camera_transform)
handle = create_camera_space_locator(frustum_curve)
# connect the locator tx and ty to film offset x and y
handle.tx >> camera_shape.pan.horizontalPan
handle.ty >> camera_shape.pan.verticalPan
handle.sy.set(lock=False)
handle.sz.set(lock=False)
handle.sx >> handle.sy
handle.sx >> handle.sz
handle.sy.set(lock=True, keyable=False)
handle.sz.set(lock=True, keyable=False)
handle.sx >> camera_shape.zoom
pm.transformLimits(handle, sx=(0.01, 2.0), esx=(True, True))
handle.addAttr('enable', at='bool', dv=True, k=True)
handle.enable >> camera_shape.panZoomEnabled
def camera_film_offset_tool():
"""Adds a locator to the selected camera with which you can adjust the 2d
pan and zoom.
Usage :
-------
- To add it, select the camera and use camera_film_offset_tool
- To remove it, set the transformations to 0 0 1 and then simply delete
the curve
- You can also use the ``enable`` option to temporarily disable the effect
"""
camera_shape = get_selected_camera()
if not camera_shape:
raise RuntimeError("please select one camera!")
# get the camera transform node
camera_transform = camera_shape.getParent()
frustum_curve = create_frustum_curve(camera_transform)
handle = create_camera_space_locator(frustum_curve)
# connect the locator tx and ty to film offset x and y
handle.tx >> camera_shape.pan.horizontalPan
handle.ty >> camera_shape.pan.verticalPan
handle.sy.set(lock=False)
handle.sz.set(lock=False)
handle.sx >> handle.sy
handle.sx >> handle.sz
handle.sy.set(lock=True, keyable=False)
handle.sz.set(lock=True, keyable=False)
handle.sx >> camera_shape.zoom
pm.transformLimits(handle, sx=(0.01, 2.0), esx=(True, True))
handle.addAttr('enable', at='bool', dv=True, k=True)
handle.enable >> camera_shape.panZoomEnabled
def armSidesSimpleControls(module, side, colour):
shieldRotYControl = simpleControls(
side + '_shoulderShieldRotYJA_JNT',
colour=colour,
modify=1,
scale=(4, 4, 4),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'])
shieldRotXControl = simpleControls(
side + '_shoulderShieldRotXJA_JNT',
colour=colour,
modify=1,
scale=(4, 4, 4),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
shieldRotY = shieldRotYControl[side + '_shoulderShieldRotYJA_JNT']
shieldRotX = shieldRotXControl[side + '_shoulderShieldRotXJA_JNT']
pm.delete(pm.listRelatives(shieldRotX.offset, type="constraint"))
pm.parentConstraint(shieldRotY.con, shieldRotX.offset, mo=True)
if side == 'r':
simpleControls('r_gunBarrelJA_JNT',
colour=colour,
scale=(4, 4, 4),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'])
blade = simpleControls('r_bladeJA_JNT',
colour=colour,
scale=(5, 2, 13),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'rx', 'ry', 'rz'])
bladeCtrl = blade['r_bladeJA_JNT']
pm.move(0, 0, 10, bladeCtrl.ctrl.cv, os=True, r=True)
pm.transformLimits(bladeCtrl.ctrl, tz=(-20, 0), etz=(1, 1))
def placement(self):
grp2 = pm.ls("*offSet*")
fols = pm.ls("*_fol")
for num, fol in enumerate(fols):
pos = pm.xform(fol, q=1, ws=1, t=True)
oldName = fol.split("_")
newName = oldName[0] + "_" + oldName[1] + "_"
ctl = self.fControl(newName, num)
pm.xform(grp2, ws=1, t=pos)
loc = pm.spaceLocator(n="loc_{}".format(num))
pm.setAttr(loc + ".visibility", 0)
pm.xform(loc, ws=1, t=pos)
pm.pointConstraint(fol, loc)
pm.orientConstraint(fol, loc)
ctls = pm.ls("*fCTL", type="transform")
for x in ctls:
pm.transformLimits(x, tx=(-1, 1), etx=(1, 0))
pm.transformLimits(x, tx=(-1, 1), etx=(1, 1))
pm.transformLimits(x, ty=(-1, 1), ety=(1, 0))
pm.transformLimits(x, ty=(-1, 1), ety=(1, 1))
#if:
#pm.transformLimits(x, ty=(-1,1), ety=(1,0))
#pm.transformLimits(x, ty=(-1,1), ety=(1,1))
grp3 = pm.ls("*woldSpace*", type="transform")
locs = pm.ls("loc_?", "loc_??", type="transform")
for x, y in sorted(zip(grp3, locs)):
pm.parent(y, x)
grp2 = pm.ls("*offSet*")
for x, y in sorted(zip(grp2, locs)):
pm.connectAttr(y + ".translate", x + ".translate", force=True)
pm.connectAttr(y + ".rotate", x + ".rotate", force=True)
#for x in grp2:
#pm.delete(pm.normalConstraint("C_body_PLY", x, weight=1, aimVector=[0,0,1], upVector=[0,1,0], worldUpType="vector", worldUpVector=[0,1,0]))
#grp =
#for x in grp:
#pm.orientConstraint("C_body_PLY", x, mo=True)
pm.group(grp3, name="bsMan_faceRig_low_control_GRP")
def buildHoof(self, ankle, toe, inner, outer, heel, settingsNode, colour,
cleanup, blendAttr):
if not ankle:
return 'DrReverseFoot: Please supply or select joints for Ankle, Toe, Inner, Outer and Heel positions.'
self.innerLoc = coreUtils.createAlignedNode(inner, 'group',
'%s_inner_GRP' % self.name)
self.innerLoc.setParent(self.rig_grp)
innerZero = coreUtils.addParent(self.innerLoc, 'group',
'%s_inner_ZERO' % self.name)
self.outerLoc = coreUtils.createAlignedNode(outer, 'group',
'%s_outer_GRP' % self.name)
self.outerLoc.setParent(self.innerLoc)
outerZero = coreUtils.addParent(self.outerLoc, 'group',
'%s_outer_ZERO' % self.name)
self.toeLoc = coreUtils.createAlignedNode(toe, 'group',
'%s_toe_GRP' % self.name)
self.toeLoc.setParent(self.outerLoc)
toeZero = coreUtils.addParent(self.toeLoc, 'group',
'%s_toe_ZERO' % self.name)
self.heelLoc = coreUtils.createAlignedNode(heel, 'group',
'%s_heel_GRP' % self.name)
self.heelLoc.setParent(self.toeLoc)
heelZero = coreUtils.addParent(self.heelLoc, 'group',
'%s_heel_ZERO' % self.name)
self.ankleLoc = coreUtils.createAlignedNode(ankle, 'group',
'%s_ankle_GRP' % self.name)
self.ankleLoc.setParent(self.heelLoc)
ankleZero = coreUtils.addParent(self.ankleLoc, 'group',
'%s_ankle_ZERO' % self.name)
self.ikConstGrp = coreUtils.createAlignedNode(
ankle, 'group', '%s_ik_CONST' % self.name)
self.ikConstGrp.setParent(self.rig_grp)
innerZero.setParent(self.ikConstGrp)
self.fkConstGrp = coreUtils.createAlignedNode(
ankle, 'group', '%s_fk_CONST' % self.name)
self.fkConstGrp.setParent(self.rig_grp)
self.constGrp = coreUtils.createAlignedNode(ankle, 'group',
'%s_CONST' % self.name)
self.constGrp.setParent(self.rig_grp)
j = coreUtils.addChild(self.constGrp, 'joint', '%s_JNT' % self.name)
self.joints.append(j)
if not blendAttr:
blendAttr = pmc.addAttr(self.main_grp,
ln='ik_fk_blend',
at='double',
k=1,
h=0)
if not settingsNode:
settingsNode = self.main_grp
pmc.addAttr(settingsNode, longName='heel_toe', at='double', k=1, h=0)
pmc.addAttr(settingsNode, longName='side_side', at='double', k=1, h=0)
settingsNode.heel_toe.connect(self.heelLoc.rx)
settingsNode.heel_toe.connect(self.toeLoc.rx)
settingsNode.side_side.connect(self.innerLoc.rz)
settingsNode.side_side.connect(self.outerLoc.rz)
pmc.transformLimits(self.heelLoc, rx=(-45, 0), erx=(0, 1))
pmc.transformLimits(self.toeLoc, rx=(0, 45), erx=(1, 0))
pmc.transformLimits(self.innerLoc, rz=(-45, 0), erz=(0, 1))
pmc.transformLimits(self.outerLoc, rz=(0, 45), erz=(1, 0))
con = pmc.parentConstraint(self.ankleLoc,
self.fkConstGrp,
self.constGrp,
mo=0)
pmc.connectAttr(blendAttr, '%s.%sW1' % (con.name(), self.fkConstGrp))
rev = coreUtils.reverse(blendAttr,
name='rev_%sIkFkBlend_UTL' % self.name)
rev.outputX.connect('%s.%sW0' % (con.name(), self.ankleLoc))
# connections
self.exposeSockets({'ankle': self.ankleLoc})
if cleanup:
self.cleanup()
def run(self):
shouldCreateOffset = False
if self.createFollowerOffset == 0:
# Always
shouldCreateOffset = True
elif self.createFollowerOffset == 1 and self.follower.nodeType(
) != 'joint':
# Exclude Joints and the follower is not a joint
shouldCreateOffset = True
_follower = self.follower
_toeFollower = self.toeFollower
if shouldCreateOffset:
_follower = pulse.nodes.createOffsetTransform(self.follower)
_toeFollower = pulse.nodes.createOffsetTransform(self.toeFollower)
# TODO(bsayre): expose as option
self.useCustomAttrs = False
if self.useCustomAttrs:
# create 'lift' and 'ballToe' blend attrs
self.control.addAttr("ballToe",
min=0,
max=1,
at='double',
defaultValue=0,
keyable=1)
ballToeAttr = self.control.attr('ballToe')
self.control.addAttr("lift",
min=0,
max=1,
at='double',
defaultValue=0,
keyable=1)
liftAttr = self.control.attr('lift')
lockedAttrs = ['tx', 'ty', 'tz', 'sx', 'sy', 'sz']
else:
# use tx and tz to control ball toe and lift blend
ballToeAttr = self.control.tx
liftAttr = self.control.tz
# configure magic control
# limit translate attrs and use them to drive blends
pm.transformLimits(self.control,
tx=(0, 1),
tz=(0, 1),
etz=(True, True),
etx=(True, True))
lockedAttrs = ['ty', 'sx', 'sy', 'sz']
# lockup attributes on the magic control
for attrName in lockedAttrs:
attr = self.control.attr(attrName)
attr.setKeyable(False)
attr.showInChannelBox(False)
attr.setLocked(True)
# transform that will contain the final results of planted targets
if self.plantedTarget:
planted_tgt = self.plantedTarget
else:
planted_tgt = pm.group(em=True,
p=self.control,
n='{0}_mf_anklePlanted_tgt'.format(
self.follower.nodeName()))
# use liftControl directly as target
lifted_tgt = self.liftControl
# toe tgt is only used for the toe follower, not the main ankle follower
# (keeps toe control fully locked when using ball pivot)
toeDown_tgt = pm.group(em=True,
p=self.toePivot,
n='{0}_mf_toeDown_tgt'.format(
self.toeFollower.nodeName()))
toeUp_tgt = pm.group(em=True,
p=_toeFollower.getParent(),
n='{0}_mf_toeUp_tgt'.format(
self.toeFollower.nodeName()))
# ball pivot will contain result of both toe and ball pivot
ballToe_tgt = pm.group(em=True,
p=self.ballPivot,
n='{0}_mf_ballToe_tgt'.format(
self.follower.nodeName()))
heel_tgt = pm.group(em=True,
p=self.heelPivot,
n='{0}_mf_heel_tgt'.format(
self.follower.nodeName()))
followerMtx = pulse.nodes.getWorldMatrix(self.follower)
toeFollowerMtx = pulse.nodes.getWorldMatrix(self.toeFollower)
# update pivots to match world rotation of control and create
# offset so that direct connect rotations will match up
for node in (self.toePivot, self.ballPivot, self.heelPivot):
followerMtx.translate = (0, 0, 0)
followerMtx.scale = (1, 1, 1)
pulse.nodes.setWorldMatrix(node, followerMtx)
pulse.nodes.createOffsetTransform(node)
if node == self.toePivot:
# after orienting toe pivot, re-parent ballPivot
self.ballPivot.setParent(self.toePivot)
# update toe target transforms to match toe follower transform
for node in (toeDown_tgt, toeUp_tgt):
pulse.nodes.setWorldMatrix(node, toeFollowerMtx)
# update target transforms to match follower transform
# (basically preserves offsets on the follower)
for node in (ballToe_tgt, heel_tgt): # , ankle_tgt):
pulse.nodes.setWorldMatrix(node, followerMtx)
# connect direct rotations to heel pivot done after creating targets so that
# the targets WILL move to reflect magic control non-zero rotations (if any)
self.control.r >> self.heelPivot.r
# connect blended rotation to toe / ball pivots
# use ballToe attr to drive the blend (0 == ball, 1 == toe)
toeRotBlendAttr = pulse.utilnodes.blend2(self.control.r, (0, 0, 0),
ballToeAttr)
ballRotBlendAttr = pulse.utilnodes.blend2((0, 0, 0), self.control.r,
ballToeAttr)
toeRotBlendAttr >> self.toePivot.r
ballRotBlendAttr >> self.ballPivot.r
# hide and lock the now-connected pivots
for node in (self.toePivot, self.ballPivot, self.heelPivot):
node.t.lock()
node.r.lock()
node.s.lock()
node.v.set(False)
# create condition to switch between ball/toe and heel pivots
# TODO(bsayre): use dot-product towards up to determine toe vs heel
isToeRollAttr = pulse.utilnodes.condition(self.control.ry, 0, [1], [0],
2)
plantedMtxAttr = pulse.utilnodes.choice(isToeRollAttr, heel_tgt.wm,
ballToe_tgt.wm)
# connect final planted ankle matrix to ankle target transform
pulse.nodes.connectMatrix(plantedMtxAttr, planted_tgt,
pulse.nodes.ConnectMatrixMethod.SNAP)
planted_tgt.t.lock()
planted_tgt.r.lock()
planted_tgt.s.lock()
planted_tgt.v.setKeyable(False)
# create matrix blend between planted and lifted targets
# use lift attr to drive the blend (0 == planted, 1 == lifted)
plantedLiftedBlendAttr = self.createMatrixBlend(
planted_tgt.wm, lifted_tgt.wm, liftAttr,
'{0}_mf_plantedLiftedBlend'.format(self.follower.nodeName()))
# connect final matrix to follower
# TODO(bsayre): this connect eliminates all transform inheritance, is
# world space control what we want? or do we need to inject offsets and
# allow parent transforms to come through
pulse.nodes.connectMatrix(plantedLiftedBlendAttr, _follower,
pulse.nodes.ConnectMatrixMethod.SNAP)
# create toe up/down matrix blend, (0 == toe-up, 1 == toe-down/ball pivot)
# in order to do this, reverse ballToe attr, then multiply by isToeRoll
# to ensure toe-down is not active when not using toe pivots
# reverse ballToeAttr, so that 1 == toe-down/ball
ballToeReverseAttr = pulse.utilnodes.reverse(ballToeAttr)
# multiply by isToe to ensure ball not active while using heel pivot
isToeAndBallAttr = pulse.utilnodes.multiply(ballToeReverseAttr,
isToeRollAttr)
# multiply by 1-liftAttr to ensure ball not active while lifting
liftReverseAttr = pulse.utilnodes.reverse(liftAttr)
toeUpDownBlendAttr = pulse.utilnodes.multiply(isToeAndBallAttr,
liftReverseAttr)
ballToeMtxBlendAttr = self.createMatrixBlend(
toeUp_tgt.wm, toeDown_tgt.wm, toeUpDownBlendAttr,
'{0}_mf_toeUpDownBlend'.format(self.toeFollower.nodeName()))
# connect final toe rotations to toeFollower
# TODO(bsayre): parent both tgts to ankle somehow to prevent locking
pulse.nodes.connectMatrix(ballToeMtxBlendAttr, _toeFollower,
pulse.nodes.ConnectMatrixMethod.SNAP)
# add meta data to controls
ctlData = {
'plantedTarget': planted_tgt,
'liftControl': self.liftControl,
}
meta.setMetaData(self.control, MAGIC_FEET_CTL_METACLASSNAME, ctlData,
False)
liftCtlData = {'control': self.control}
meta.setMetaData(self.liftControl, MAGIC_FEET_LIFT_CTL_METACLASSNAME,
liftCtlData, False)
def buildFoot(self, ankle, foot, ball, toe, inner, outer, heel,
settingsNode, blendAttr, colour, cleanup):
# Make duplicate joint chains
self.tripleChain = systemUtils.tripleChain(
joints=[ankle, foot, ball, toe], name=self.name, flip=0)
ikConst_grp = coreUtils.addParent(self.tripleChain['ikChain'][0],
'group',
'%s_ikConst_GRP' % self.name)
fkConst_grp = coreUtils.addParent(self.tripleChain['fkChain'][0],
'group',
'%s_fkConst_GRP' % self.name)
resultConst_grp = coreUtils.addParent(
self.tripleChain['resultChain'][0], 'group',
'%s_resultConst_GRP' % self.name)
self.tripleChain['main_grp'].setParent(self.rig_grp)
if blendAttr:
par = pmc.parentConstraint(ikConst_grp,
fkConst_grp,
resultConst_grp,
mo=0)
attr = pmc.Attribute('%s.%sW1' % (par.name(), fkConst_grp.name()))
blendAttr.connect(attr)
attr = pmc.Attribute('%s.%sW0' % (par.name(), ikConst_grp.name()))
blend_rev = coreUtils.reverse(blendAttr,
'reverse_%s_blend, UTL' % self.name)
blend_rev.outputX.connect(attr)
for bc in self.tripleChain['blendColors']:
blendAttr.connect(bc.blender)
# Orientation for controls
axis = 'x'
if self.tripleChain['resultChain'][1].tx.get() < 0.0:
axis = '-x'
ctrlSize = coreUtils.getDistance(
self.tripleChain['resultChain'][0],
self.tripleChain['resultChain'][1]) * .5
# ikHandles
footIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_foot_ikHandle' % self.name,
startJoint=self.tripleChain['ikChain'][0],
endEffector=self.tripleChain['ikChain'][1],
setupForRPsolver=1)[0]
footIkHandle.setParent(self.rig_grp)
footIkHandleConst = coreUtils.addParent(
footIkHandle, 'group', '%s_footIkHandle_CONST' % self.name)
ballIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_ball_ikHandle' % self.name,
startJoint=self.tripleChain['ikChain'][1],
endEffector=self.tripleChain['ikChain'][2],
setupForRPsolver=1)[0]
ballIkHandle.setParent(self.rig_grp)
ballIkHandleConst = coreUtils.addParent(
ballIkHandle, 'group', '%s_ballIkHandle_CONST' % self.name)
toeIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_toe_ikHandle' % self.name,
startJoint=self.tripleChain['ikChain'][2],
endEffector=self.tripleChain['ikChain'][3],
setupForRPsolver=1)[0]
toeIkHandle.setParent(self.rig_grp)
toeIkHandleConst = coreUtils.addParent(
toeIkHandle, 'group', '%s_toeIkHandle_CONST' % self.name)
# ikCtrls
self.heelIkCtrl = controls.squareCtrl(name='%s_heel_ik_CTRL' %
self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.heelIkCtrl, heel)
self.heelIkCtrl.setParent(self.ctrls_grp)
self.ikCtrls_grp = coreUtils.addParent(self.heelIkCtrl, 'group',
'%s_ikCtrls_GRP' % self.name)
coreUtils.addParent(self.heelIkCtrl, 'group',
'%s_heelIkCtrl_ZERO' % self.name)
self.ctrls.append(self.heelIkCtrl)
self.toeIkCtrl = controls.squareCtrl(name='%s_toe_ik_CTRL' % self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.toeIkCtrl, self.tripleChain['ikChain'][3])
self.toeIkCtrl.setParent(self.heelIkCtrl)
coreUtils.addParent(self.toeIkCtrl, 'group',
'%s_toeIkCtrl_ZERO' % self.name)
self.ctrls.append(self.toeIkCtrl)
self.innerLoc = coreUtils.createAlignedNode(inner, 'group',
'%s_inner_GRP' % self.name)
self.innerLoc.setParent(self.toeIkCtrl)
innerZero = coreUtils.addParent(self.innerLoc, 'group',
'%s_inner_ZERO' % self.name)
self.outerLoc = coreUtils.createAlignedNode(outer, 'group',
'%s_outer_GRP' % self.name)
self.outerLoc.setParent(self.innerLoc)
outerZero = coreUtils.addParent(self.outerLoc, 'group',
'%s_outer_ZERO' % self.name)
self.ballPivotIkCtrl = controls.squareCtrl(
name='%s_ballPivot_ik_CTRL' % self.name, axis=axis, size=ctrlSize)
coreUtils.align(self.ballPivotIkCtrl, self.tripleChain['ikChain'][2])
self.ballPivotIkCtrl.setParent(self.outerLoc)
coreUtils.addParent(self.ballPivotIkCtrl, 'group',
'%s_ballPivotIkCtrl_ZERO' % self.name)
inv_grp = coreUtils.addParent(self.ballPivotIkCtrl, 'group',
'%s_ballPivotIkCtrlRotX_INV' % self.name)
inv_uc = coreUtils.convert(self.ballPivotIkCtrl.rx,
-1.0,
name='uc_%s_ballPivotIkCtrlRotX_UTL' %
self.name)
inv_uc.output.connect(inv_grp.rx)
pmc.parentConstraint(self.ballPivotIkCtrl, toeIkHandleConst, mo=1)
self.ctrls.append(self.ballPivotIkCtrl)
self.ballPivotIkCtrl.rx.connect(self.outerLoc.rx)
pmc.transformLimits(self.innerLoc, rx=(-45, 0), erx=(0, 1))
self.ballPivotIkCtrl.rx.connect(self.innerLoc.rx)
pmc.transformLimits(self.outerLoc, rx=(0, 45), erx=(1, 0))
self.ballIkCtrl = controls.squareCtrl(name='%s_ball_ik_CTRL' %
self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.ballIkCtrl, self.tripleChain['ikChain'][2])
self.ballIkCtrl.setParent(self.ballPivotIkCtrl)
coreUtils.addParent(self.ballIkCtrl, 'group',
'%s_ballIkCtrl_ZERO' % self.name)
pmc.parentConstraint(self.ballIkCtrl, ballIkHandleConst, mo=1)
self.ctrls.append(self.ballIkCtrl)
self.footIkCtrl = controls.squareCtrl(name='%s_foot_ik_CTRL' %
self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.footIkCtrl, self.tripleChain['ikChain'][1])
self.footIkCtrl.setParent(self.ballIkCtrl)
coreUtils.addParent(self.footIkCtrl, 'group',
'%s_footIkCtrl_ZERO' % self.name)
pmc.parentConstraint(self.footIkCtrl, footIkHandleConst, mo=1)
pmc.parentConstraint(self.footIkCtrl, ikConst_grp, mo=1)
self.ctrls.append(self.footIkCtrl)
# fkCtrls
self.footFkCtrl = controls.squareCtrl(name='%s_foot_fk_CTRL' %
self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.footFkCtrl, self.tripleChain['fkChain'][1])
self.footFkCtrl.setParent(self.ctrls_grp)
self.fkCtrls_grp = coreUtils.addParent(self.footFkCtrl, 'group',
'%s_fkCtrls_GRP' % self.name)
coreUtils.addParent(self.footFkCtrl, 'group',
'%s_footFkCtrl_ZERO' % self.name)
pmc.parentConstraint(self.footFkCtrl, self.tripleChain['fkChain'][1])
self.ctrls.append(self.footFkCtrl)
self.ballFkCtrl = controls.squareCtrl(name='%s_ball_fk_CTRL' %
self.name,
axis=axis,
size=ctrlSize)
coreUtils.align(self.ballFkCtrl, self.tripleChain['fkChain'][2])
self.ballFkCtrl.setParent(self.footFkCtrl)
coreUtils.addParent(self.ballFkCtrl, 'group',
'%s_ballFkCtrl_ZERO' % self.name)
pmc.parentConstraint(self.ballFkCtrl, self.tripleChain['fkChain'][2])
self.ctrls.append(self.ballFkCtrl)
coreUtils.colorize(colour, self.ctrls)
for ctrl in self.ctrls:
pmc.select('%s.cv[*]' % ctrl.name())
if ctrl != self.ballPivotIkCtrl:
pmc.scale(3.0, scaleZ=1)
else:
pmc.scale(3.0, scaleY=1)
pmc.parentConstraint(self.fkCtrls_grp, fkConst_grp, mo=1)
for joint in self.tripleChain['resultChain']:
self.joints.append(joint)
# connections
self.exposeSockets({'ikFoot': self.tripleChain['ikChain'][0]})
if cleanup:
self.cleanup()
def kiddoRigModules():
print 'Create kiddo rig modules'
bodyModule = rig_module('body')
pm.parent('mainJA_JNT', bodyModule.skeleton)
main = rig_control(name='main',
shape='box',
targetOffset='mainJA_JNT',
constrain='mainJA_JNT',
parentOffset=bodyModule.controls,
scale=(45, 10, 50),
colour='white')
main.gimbal = createCtrlGimbal(main)
main.pivot = createCtrlPivot(main, overrideScale=(10, 10, 10))
upperBody = rig_control(name='upperBody',
shape='box',
modify=1,
targetOffset='mainJA_JNT',
constrainOffset=main.con,
scale=(35, 15, 40),
colour='yellow',
parentOffset=bodyModule.controls,
lockHideAttrs=['tx', 'ty', 'tz'],
rotateOrder=2)
pm.move(upperBody.ctrl.cv, [0, 10, 0], relative=True, objectSpace=True)
upperWaistXYZ = simpleControls(
['upperWaistY_JA_JNT', 'upperWaistZ_JA_JNT', 'upperWaistX_JA_JNT'],
modify=1,
scale=(45, 10, 50),
parentOffset=bodyModule.parts,
lockHideAttrs=['tx', 'ty', 'tz'])
upperWaistY = upperWaistXYZ['upperWaistY_JA_JNT']
upperWaistZ = upperWaistXYZ['upperWaistZ_JA_JNT']
upperWaistX = upperWaistXYZ['upperWaistX_JA_JNT']
pm.hide(upperWaistY.offset, upperWaistZ.offset, upperWaistX.offset)
constrainObject(upperBody.modify, [upperBody.offset, 'worldSpace_GRP'],
upperBody.ctrl, ['main', 'world'],
type='orientConstraint')
constrainObject(upperWaistY.modify, [upperWaistY.offset, 'worldSpace_GRP'],
upperBody.ctrl, ['main', 'world'],
type='orientConstraint',
skip=('x', 'z'))
constrainObject(upperWaistZ.modify, [upperWaistZ.offset, 'worldSpace_GRP'],
upperBody.ctrl, ['main', 'world'],
type='orientConstraint',
skip=('x', 'y'))
constrainObject(upperWaistX.modify, [upperWaistX.offset, 'worldSpace_GRP'],
upperBody.ctrl, ['main', 'world'],
type='orientConstraint',
skip=('z', 'y'))
pm.connectAttr(upperBody.ctrl.rotateX, upperWaistX.ctrl.rotateX)
pm.connectAttr(upperBody.ctrl.rotateY, upperWaistY.ctrl.rotateY)
pm.connectAttr(upperBody.ctrl.rotateZ, upperWaistZ.ctrl.rotateZ)
lowerBody = rig_control(name='lowerBody',
shape='box',
modify=1,
targetOffset='lowerBodyJA_JNT',
constrainOffset=main.con,
scale=(40, 20, 30),
colour='green',
parentOffset=bodyModule.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'],
rotateOrder=2)
constrainObject(lowerBody.modify, [lowerBody.offset, 'worldSpace_GRP'],
lowerBody.ctrl, ['main', 'world'],
type='orientConstraint',
skip=('x', 'z'))
pm.parentConstraint(lowerBody.con, 'lowerBodyJA_JNT', mo=True)
pm.move(lowerBody.ctrl.cv, [0, -10, 0], relative=True, objectSpace=True)
biped = rig_biped()
biped.spineConnection = 'upperWaistX_JA_JNT'
biped.pelvisConnection = 'lowerBodyJA_JNT'
biped.centerConnection = 'mainJA_JNT'
for side in ['l', 'r']:
armModule = biped.arm(side, ctrlSize=10)
fingersModule = biped.hand(side, ctrlSize=2.5)
shoulderModule = biped.shoulder(side, ctrlSize=12)
biped.connectArmShoulder(side)
secColour = 'deepskyblue'
if side == 'r':
secColour = 'magenta'
# make leg
legName = side + '_leg'
legModule = rig_module(legName)
hipZJnt = side + '_hipZ_JA_JNT'
hipYJnt = side + '_hipY_JA_JNT'
legJnt = side + '_legJA_JNT'
kneeJnt = side + '_kneeJA_JNT'
ankleJnt = side + '_ankleJA_JNT'
footJnt = side + '_footJA_JNT'
pm.setAttr(hipYJnt + '.rotateOrder', 2)
# chain IK
legJntIK = rig_transform(0,
name=side + '_legIK',
type='joint',
target=legJnt,
parent=legModule.parts).object
kneeJntIK = rig_transform(0,
name=side + '_kneeIK',
type='joint',
target=kneeJnt).object
ankleJntIK = rig_transform(
0,
name=side + '_ankleIK',
type='joint',
target=ankleJnt,
).object
footJntIK = rig_transform(
0,
name=side + '_footIK',
type='joint',
target=footJnt,
).object
chainIK = [legJntIK, kneeJntIK, ankleJntIK, footJntIK]
chainParent(chainIK)
chainIK.reverse()
# create ik
ik = rig_ik(legName, legJntIK, footJntIK, 'ikSpringSolver')
pm.parent(ik.handle, legModule.parts)
# pole vector
legPoleVector = rig_control(side=side,
name='legPV',
shape='pointer',
modify=1,
lockHideAttrs=['rx', 'ry', 'rz'],
targetOffset=[legJnt, footJnt],
parentOffset=legModule.parts,
scale=(2, 2, 2))
pm.delete(pm.aimConstraint(ankleJnt, legPoleVector.offset, mo=False))
kneePos = pm.xform(kneeJnt, translation=True, query=True, ws=True)
poleVectorPos = pm.xform(legPoleVector.con,
translation=True,
query=True,
ws=True)
pvDistance = lengthVector(kneePos, poleVectorPos)
pm.xform(legPoleVector.offset,
translation=[-25, 0, 0],
os=True,
r=True)
pm.poleVectorConstraint(legPoleVector.con, ik.handle) # create pv
#pm.parentConstraint(biped.centerConnection, legPoleVector.offset, mo=True)
pm.parentConstraint(hipYJnt, legPoleVector.offset, mo=True)
if side == 'r':
pm.rotate(legPoleVector.ctrl.cv, 0, -90, 0, r=True, os=True)
else:
pm.rotate(legPoleVector.ctrl.cv, 0, 90, 0, r=True, os=True)
# create foot control
foot = rig_control(side=side,
name='foot',
shape='box',
modify=1,
scale=(13, 13, 13),
parentOffset=legModule.controls,
lockHideAttrs=['rx', 'ry', 'rz'])
pm.delete(pm.pointConstraint(footJnt, foot.offset))
pm.parentConstraint(foot.con, ik.handle, mo=True)
#pm.pointConstraint( foot.con, legPoleVector.modify, mo=True )
foot.gimbal = createCtrlGimbal(foot)
foot.pivot = createCtrlPivot(foot)
constrainObject(
foot.offset,
[biped.pelvisConnection, biped.centerConnection, 'worldSpace_GRP'],
foot.ctrl, ['pelvis', 'main', 'world'],
type='parentConstraint')
pm.setAttr(foot.ctrl.space, 2)
pm.addAttr(foot.ctrl, longName='twist', at='float', k=True)
pm.addAttr(foot.ctrl,
longName='springBiasBottom',
at='float',
min=0,
max=1,
k=True,
dv=0)
pm.addAttr(foot.ctrl,
longName='springBiasTop',
at='float',
min=0,
max=1,
k=True,
dv=0.5)
pm.connectAttr(foot.ctrl.twist, ik.handle.twist)
pm.connectAttr(foot.ctrl.springBiasBottom,
ik.handle +
'.springAngleBias[0].springAngleBias_FloatValue',
f=True)
pm.connectAttr(foot.ctrl.springBiasTop,
ik.handle +
'.springAngleBias[1].springAngleBias_FloatValue',
f=True)
# create hip aims
hipAimZ_loc = rig_transform(0,
name=side + '_hipAimZ',
type='locator',
parent=legModule.parts,
target=hipZJnt).object
footAimZ_loc = rig_transform(0,
name=side + '_footAimZ',
type='locator',
parent=legModule.parts).object
pm.pointConstraint(biped.pelvisConnection, hipAimZ_loc, mo=True)
pm.parentConstraint(foot.con, footAimZ_loc)
# z rotation
hipAimZ = mm.eval('rig_makePiston("' + footAimZ_loc + '", "' +
hipAimZ_loc + '", "' + side + '_hipAimZ");')
hipZ = rig_control(side=side,
name='hipRoll',
shape='sphere',
modify=1,
scale=(5, 5, 7),
parentOffset=legModule.parts,
targetOffset=hipZJnt,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'ry'],
rotateOrder=0)
pm.parentConstraint(hipZ.con, hipZJnt, mo=True)
pm.parentConstraint(lowerBody.con, hipZ.offset, mo=True)
rotCon = pm.orientConstraint(hipZ.offset,
hipAimZ_loc,
hipZ.modify,
mo=True,
skip=('x', 'y'))
targetZ = rotCon.getWeightAliasList()
#pm.addAttr(hipZ.ctrl, longName='aim', at='float', k=True, min=0, max=1,
# dv=1)
#pm.connectAttr ( hipZ.ctrl.aim, target )
# y rotation
hipAimY_loc = rig_transform(0,
name=side + '_hipAimY',
type='locator',
parent=legModule.parts,
target=hipYJnt).object
footAimY_loc = rig_transform(0,
name=side + '_footAimY',
type='locator',
parent=legModule.parts).object
pm.pointConstraint(hipZJnt, hipAimY_loc, mo=True)
pm.parentConstraint(foot.con, footAimY_loc)
hipAimY = mm.eval('rig_makePiston("' + footAimY_loc + '", "' +
hipAimY_loc + '", '
'"' + side + '_hipAimY");')
pm.setAttr(side + '_hipAimZ_LOC.rotateOrder', 4)
hipY = rig_control(side=side,
name='hipYaw',
shape='sphere',
modify=2,
scale=(5, 7, 5),
parentOffset=legModule.controls,
targetOffset=hipYJnt,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'],
rotateOrder=2)
pm.parentConstraint(hipY.con, hipYJnt, mo=True)
pm.parentConstraint(hipZ.con, hipY.offset, mo=True)
#rotCon = pm.parentConstraint(hipAimY_loc, hipY.modify, mo=True,
# skipTranslate=('x', 'y', 'z'),
# skipRotate=('x', 'z'))
rotCon = pm.orientConstraint(hipY.offset,
hipAimY_loc,
hipY.modify[0],
mo=True,
skip=('x', 'z'))
targetY = rotCon.getWeightAliasList()
pm.addAttr(hipY.ctrl,
longName='aim',
at='float',
k=True,
min=0,
max=1,
dv=1)
pm.connectAttr(hipY.ctrl.aim, targetY[1])
pm.connectAttr(hipY.ctrl.aim, targetZ[1])
connectReverse(name=side + '_leg',
input=(hipY.ctrl.aim, hipY.ctrl.aim, 0),
output=(targetY[0], targetZ[0], 0))
pm.setAttr(rotCon.interpType, 2)
pm.transformLimits(hipY.modify[0], ry=(-30, 10), ery=(1, 1))
pm.addAttr(hipY.ctrl,
longName='aimRotation',
at='float',
k=True,
min=0,
max=10,
dv=0)
pm.addAttr(hipY.ctrl,
longName='limitOutRotation',
at='float',
k=True,
min=0,
max=10,
dv=3)
pm.addAttr(hipY.ctrl,
longName='limitInRotation',
at='float',
k=True,
min=0,
max=10,
dv=0)
hipY.ctrl.limitOutRotation.set(cb=True)
hipY.ctrl.limitInRotation.set(cb=True)
pm.setDrivenKeyframe(hipY.modify[0] + '.minRotYLimit',
cd=hipY.ctrl.limitOutRotation,
dv=0,
v=-45)
pm.setDrivenKeyframe(hipY.modify[0] + '.minRotYLimit',
cd=hipY.ctrl.limitOutRotation,
dv=10,
v=0)
pm.setDrivenKeyframe(hipY.modify[0] + '.maxRotYLimit',
cd=hipY.ctrl.limitInRotation,
dv=0,
v=10)
pm.setDrivenKeyframe(hipY.modify[0] + '.maxRotYLimit',
cd=hipY.ctrl.limitInRotation,
dv=10,
v=0)
rotCon = pm.orientConstraint(hipY.offset,
hipY.modify[0],
hipY.modify[1],
mo=True)
conTargets = rotCon.getWeightAliasList()
pm.setDrivenKeyframe(conTargets[0],
cd=hipY.ctrl.aimRotation,
dv=0,
v=1)
pm.setDrivenKeyframe(conTargets[0],
cd=hipY.ctrl.aimRotation,
dv=10,
v=0)
connectReverse(name=side + '_hipYTarget',
input=(conTargets[0], 0, 0),
output=(conTargets[1], 0, 0))
# constrain shizzle
legTop = rig_transform(0,
name=side + '_legTop',
target=legJnt,
parent=legModule.skeleton).object
pm.setAttr(legTop + '.inheritsTransform', 0)
pm.scaleConstraint('worldSpace_GRP', legTop)
legSkeletonParts = rig_transform(0,
name=side + '_legSkeletonParts',
parent=legTop).object
pm.parent(hipAimY, hipAimZ, legModule.parts)
pm.parent(legJntIK, legJnt, legSkeletonParts)
pm.hide(legJntIK)
pm.parentConstraint(hipYJnt,
legTop,
mo=True,
skipRotate=('x', 'y', 'z'))
#pm.connectAttr(legJntIK+'.rotate', legJnt+'.rotate')
pm.connectAttr(kneeJntIK + '.rotate', kneeJnt + '.rotate')
pm.connectAttr(ankleJntIK + '.rotate', ankleJnt + '.rotate')
multiplyDivideNode('legRotate',
'multiply',
input1=[
legJntIK + '.rotateX', legJntIK + '.rotateY',
legJntIK + '.rotateZ'
],
input2=[1, hipY.ctrl.aim, hipY.ctrl.aim],
output=[
legJnt + '.rotateX', legJnt + '.rotateY',
legJnt + '.rotateZ'
])
pm.parent(hipZJnt, legModule.skeleton)
pm.parent(hipYJnt, legModule.skeleton)
footJnts = [
side + '_heelRotY_JA_JNT', side + '_footRotX_JA_JNT',
side + '_footRotY_JA_JNT', side + '_footRotZ_JA_JNT'
]
footControls = simpleControls(footJnts,
modify=2,
scale=(11, 3, 20),
parentOffset=legModule.parts,
colour=secColour,
lockHideAttrs=['tx', 'ty', 'tz'])
#footControls[side+'']
ankle = rig_control(side=side,
name='ankle',
shape='box',
modify=1,
scale=(10, 6, 8),
colour=secColour,
parentOffset=legModule.controls,
targetOffset=side + '_footRotZ_JA_JNT',
lockHideAttrs=['tx', 'ty', 'tz', 'ry'])
pm.parentConstraint(footJnt, ankle.offset, mo=True)
heel = footControls[side + '_heelRotY_JA_JNT']
footRotX = footControls[side + '_footRotX_JA_JNT']
footRotY = footControls[side + '_footRotY_JA_JNT']
footRotZ = footControls[side + '_footRotZ_JA_JNT']
pm.parent(heel.offset, legModule.controls)
heel.ctrl.rotateX.setKeyable(False)
heel.ctrl.rotateX.setLocked(True)
heel.ctrl.rotateZ.setKeyable(False)
heel.ctrl.rotateZ.setLocked(True)
pm.parentConstraint(footRotY.con, heel.modify[0], mo=True)
pm.parentConstraint(footRotZ.con, footRotY.modify[0], mo=True)
pm.parentConstraint(footRotX.con, footRotZ.modify[0], mo=True)
footSpace = footJnt
if side == 'l':
footSpace = rig_transform(0,
name='l_footSpace',
parent=legModule.parts,
target=footJnt).object
pm.setAttr(footSpace + '.rotateX', 0)
pm.parentConstraint(footJnt, footSpace, mo=True)
toeSpaceList = ('lowerBody', 'foot', 'main', 'world')
constrainObject(heel.modify[1], [
biped.pelvisConnection, footSpace, biped.centerConnection,
'worldSpace_GRP'
],
heel.ctrl,
toeSpaceList,
type='orientConstraint',
skip=('x', 'z'))
constrainObject(footRotX.modify[0], [
biped.pelvisConnection, footSpace, biped.centerConnection,
'worldSpace_GRP'
],
footRotX.ctrl,
toeSpaceList,
type='orientConstraint',
skip=('y', 'z'))
constrainObject(footRotZ.modify[1], [
biped.pelvisConnection, footSpace, biped.centerConnection,
'worldSpace_GRP'
],
footRotZ.ctrl,
toeSpaceList,
type='orientConstraint',
skip=('x', 'y'))
pm.connectAttr(ankle.ctrl.rotateX, footRotX.ctrl.rotateX)
#pm.connectAttr( ankle.ctrl.rotateY, heel.ctrl.rotateY )
#connectNegative(ankle.ctrl.rotateY, heel.ctrl.rotateY)
pm.connectAttr(ankle.ctrl.rotateZ, footRotZ.ctrl.rotateZ)
pm.addAttr(ankle.ctrl,
ln='SPACES',
at='enum',
enumName='___________',
k=True)
ankle.ctrl.SPACES.setLocked(True)
pm.addAttr(ankle.ctrl,
ln='rollSpace',
at='enum',
enumName='lowerBody:foot:main:world',
k=True)
#pm.addAttr(ankle.ctrl, ln='yawSpace', at='enum',
# enumName='lowerBody:foot:main:world', k=True)
pm.addAttr(ankle.ctrl,
ln='pitchSpace',
at='enum',
enumName='lowerBody:foot:main:world',
k=True)
pm.connectAttr(ankle.ctrl.rollSpace, footRotX.ctrl.space)
#pm.connectAttr( ankle.ctrl.yawSpace, heel.ctrl.space)
pm.connectAttr(ankle.ctrl.pitchSpace, footRotZ.ctrl.space)
pm.addAttr(ankle.ctrl,
ln='MOTION',
at='enum',
enumName='___________',
k=True)
ankle.ctrl.MOTION.setLocked(True)
pm.addAttr(ankle.ctrl,
longName='footFangs',
at='float',
k=True,
min=0,
max=10,
dv=0)
pm.addAttr(ankle.ctrl,
longName='toeFangs',
at='float',
k=True,
min=0,
max=10,
dv=0)
fangsJnt = pm.PyNode(side + '_toeFangsJA_JNT')
toeFangsJnt = pm.PyNode(side + '_footFangsJA_JNT')
fangsTranslate = fangsJnt.translate.get()
pm.setDrivenKeyframe(fangsJnt.translateX,
cd=ankle.ctrl.footFangs,
dv=0,
v=fangsTranslate[0])
pm.setDrivenKeyframe(fangsJnt.translateY,
cd=ankle.ctrl.footFangs,
dv=0,
v=fangsTranslate[1])
pm.setDrivenKeyframe(fangsJnt.translateZ,
cd=ankle.ctrl.footFangs,
dv=0,
v=fangsTranslate[2])
pm.move(0, 1.5, 0, fangsJnt, r=True, os=True)
fangsTranslate = fangsJnt.translate.get()
pm.move(0, -1.5, 0, fangsJnt, r=True, os=True)
pm.setDrivenKeyframe(fangsJnt.translateX,
cd=ankle.ctrl.footFangs,
dv=10,
v=fangsTranslate[0])
pm.setDrivenKeyframe(fangsJnt.translateY,
cd=ankle.ctrl.footFangs,
dv=10,
v=fangsTranslate[1])
pm.setDrivenKeyframe(fangsJnt.translateZ,
cd=ankle.ctrl.footFangs,
dv=10,
v=fangsTranslate[2])
# foot fangs
fangsTranslate = toeFangsJnt.translate.get()
pm.setDrivenKeyframe(toeFangsJnt.translateX,
cd=ankle.ctrl.toeFangs,
dv=0,
v=fangsTranslate[0])
pm.setDrivenKeyframe(toeFangsJnt.translateY,
cd=ankle.ctrl.toeFangs,
dv=0,
v=fangsTranslate[1])
pm.setDrivenKeyframe(toeFangsJnt.translateZ,
cd=ankle.ctrl.toeFangs,
dv=0,
v=fangsTranslate[2])
pm.move(0, 0, -4.7, toeFangsJnt, r=True, os=True)
fangsTranslate = toeFangsJnt.translate.get()
pm.move(0, 0, 4.7, toeFangsJnt, r=True, os=True)
pm.setDrivenKeyframe(toeFangsJnt.translateX,
cd=ankle.ctrl.toeFangs,
dv=10,
v=fangsTranslate[0])
pm.setDrivenKeyframe(toeFangsJnt.translateY,
cd=ankle.ctrl.toeFangs,
dv=10,
v=fangsTranslate[1])
pm.setDrivenKeyframe(toeFangsJnt.translateZ,
cd=ankle.ctrl.toeFangs,
dv=10,
v=fangsTranslate[2])
pm.addAttr(ankle.ctrl,
longName='toeCapRotate',
at='float',
k=True,
dv=0)
if side == 'l':
pm.connectAttr(ankle.ctrl.toeCapRotate,
'l_footCapJA_JNT.rotateX',
f=True)
else:
connectReverse(ankle.ctrl.toeCapRotate, 'r_footCapJA_JNT.rotateX')
# simple controls
legSidesSimpleControls(legModule, side, secColour)
armSidesSimpleControls(armModule, side, secColour)
# asymettrical controls
bodySimpleControls(bodyModule)
def rig_autoFlexControl(name,
shapeDriverLoc,
startEnd=(),
shapeDriven='',
flexLoc='flexShapes_LOC',
module=None,
**kwds):
scale = defaultReturn(5, 'scale', param=kwds)
shape = defaultReturn('sphere', 'shape', param=kwds)
colour = defaultReturn('red', 'colour', param=kwds)
if not cmds.objExists(flexLoc + '.' + shapeDriven):
pm.warning(flexLoc + '.' + shapeDriven +
' = does not exist ! Not making auto flex control')
return
if module == None:
parent = rig_transform(0, name=name + '_measureSetup').object
else:
parent = module.parts
distNode = rig_measure(name=name + 'FlexDistance',
start=startEnd[0],
end=startEnd[1],
parent=parent)
flexCenter = rig_control(
name=name + 'FlexCenter',
shape='box',
scale=(scale, scale, scale),
colour='white',
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'ry', 'rz'],
parentOffset=module.controls)
pm.delete(pm.parentConstraint(shapeDriverLoc, flexCenter.offset))
flexCtrl = rig_control(name=name + 'Flex',
shape=shape,
scale=(scale / 2, scale / 2, scale / 2),
parentOffset=flexCenter.con,
colour=colour,
lockHideAttrs=['tx', 'tz', 'rx', 'ry', 'rz'])
pm.delete(pm.parentConstraint(flexCenter.con, flexCtrl.offset))
rig_curveBetweenTwoPoints(flexCenter.con,
flexCtrl.con,
name=name + '_curveBetween',
degree=1,
colour=colour,
parent=flexCenter.offset)
pm.addAttr(flexCtrl.ctrl,
longName='autoFlex',
attributeType="long",
min=0,
max=1,
defaultValue=1,
keyable=True)
mdNode = multiplyDivideNode(
name + '_flexMD',
'multiply',
input1=[distNode.distance + '.globalOriginalPercent', 0, 0],
input2=[1, 1, 1],
output=[])
pmNode = plusMinusNode(name + '_flexPM', 'sum', distNode.distance,
'globalOriginalPercent', mdNode, 'outputX')
conNode = conditionNode(name + '_flexCondition', 'equal',
(pmNode, 'output1D'), ('', 0), ('', 1),
(pmNode, 'output1D'))
remapNode = remapValueNode(conNode + '.outColorR',
1,
0,
0,
1,
name=name,
valueinterp=2)
rig_animDrivenKey(flexCtrl.ctrl.autoFlex, (0, 1), mdNode + '.input2X',
(-1, 0))
rig_animDrivenKey(flexCtrl.ctrl.translateY, (0, -10),
remapNode + '.inputMin', (1, 0.8))
rig_animDrivenKey(flexCtrl.ctrl.translateY, (0, 10),
remapNode + '.outputMin', (0, 1))
pm.setAttr(remapNode + '.inputMax', 0.8)
pm.connectAttr(remapNode + '.outValue',
flexLoc + '.' + shapeDriven,
f=True)
pm.transformLimits(flexCtrl.ctrl, ty=(-10, 10), ety=(1, 1))
mdNode = multiplyDivideNode(name + '_flexOffsetMD',
'multiply',
input1=[remapNode + '.outValue', 0, 0],
input2=[10, 1, 1],
output=[flexCtrl.offset + '.translateY'])
pm.setAttr(flexCenter.ctrl.overrideDisplayType, 1)
pm.select(flexCtrl.ctrl.cv[1],
flexCtrl.ctrl.cv[27],
flexCtrl.ctrl.cv[36],
flexCtrl.ctrl.cv[46],
flexCtrl.ctrl.cv[54],
r=True)
pm.move(0, 3, 0, r=True, os=True, wd=True)
pm.select(flexCtrl.ctrl.cv[22],
flexCtrl.ctrl.cv[32],
flexCtrl.ctrl.cv[41],
flexCtrl.ctrl.cv[50],
flexCtrl.ctrl.cv[61],
r=True)
pm.move(0, -1, 0, r=True, os=True, wd=True)
return (flexCenter, flexCtrl)
def mantleCreate(charaHeight=2): #default 2, 160cm height
locM = pm.spaceLocator(name='locM')
pm.xform(locM,
ws=True,
translation=[
8.17948246602115e-16, 126.43254364390185, -8.830608530289298
],
scale=[3, 3, 3]) #shifting it into place
locR = pm.spaceLocator(name='locR')
pm.xform(locR,
ws=True,
translation=[-10, 124.043, -9.221],
scale=[3, 3, 3]) #shifting it into place
locRR = pm.spaceLocator(name='locRR')
pm.xform(locRR, ws=True, translation=[-14, 129, -1.6],
scale=[3, 3, 3]) #shifting it into place
locL = pm.spaceLocator(name='locL')
pm.xform(locL, ws=True, translation=[10, 124.043, -9.221],
scale=[3, 3, 3]) #shifting it into place
locLL = pm.spaceLocator(name='locLL')
pm.xform(locLL, ws=True, translation=[14, 129, -1.6],
scale=[3, 3, 3]) #shifting it into place
heightPosition = {} #order of data is M, R, RR, L, LL
heightPosition['1'] = [0, 117.518,
-8.237], [-9.25, 115.129,
-8.627], [-11, 120.1,
-1.00], [9.25, 115.129, -8.627
], [11, 120.1,
-1] #1 = 150cm
heightPosition['1sim'] = [0.001, 61.086,
-9.781], [-19, 77.696,
-9.919], [-28, 120.1,
-1], [19, 77.696, -9.919
], [28, 120.1, -1]
heightPosition['2'] = [
8.17948246602115e-16, 126.43254364390185, -8.830608530289298
], [-10, 124.043, -9.221], [-14, 129, -1.6], [10, 124.043,
-9.221], [14, 129,
-1.6] #2 = 160cm
heightPosition['2sim'] = [0.001, 70,
-11.002], [-21.549, 80, -10.513
], [-31, 129,
-1.6], [21.549, 80,
-10.513], [31, 129, -1.6]
heightPosition['3'] = [0, 133.789,
-13.546], [-11, 131.4,
-13.936], [-15, 136.357, -4.721
], [11, 131.4, -13.936
], [15, 136.357,
-4.721] #3 = 170cm
heightPosition['3sim'] = [0.001, 77.357, -15.717], [-25.5, 79, -15.228], [
-32, 136.357, -4.721
], [25.5, 79, -15.228], [32, 136.357, -4.721]
heightPosition['4'] = [0, 157.786,
-14.305], [-12, 155,
-14.695], [-20, 160.353, -4.5
], [12, 155, -14.695
], [20, 160.353,
-4.5] #4 = 180cm
heightPosition['4sim'] = [0.001, 101.353,
-16.476], [-25.75, 100,
-15.987], [-37, 160.353, -4.5
], [25.75, 100, -15.987
], [37, 160.353, -4.5]
#translating the locators to their position
pm.xform('loc' + 'M',
ws=True,
translation=heightPosition['%s' % (charaHeight)][0],
scale=[3, 3, 3])
pm.xform('loc' + 'R',
ws=True,
translation=heightPosition['%s' % (charaHeight)][1],
scale=[3, 3, 3])
pm.xform('loc' + 'RR',
ws=True,
translation=heightPosition['%s' % (charaHeight)][2],
scale=[3, 3, 3])
pm.xform('loc' + 'L',
ws=True,
translation=heightPosition['%s' % (charaHeight)][3],
scale=[3, 3, 3])
pm.xform('loc' + 'LL',
ws=True,
translation=heightPosition['%s' % (charaHeight)][4],
scale=[3, 3, 3])
locList = [locM, locR, locRR, locL, locLL]
locDict = {}
locSimList = []
for i in locList:
sim = pm.duplicate(i, name=i[:3] + '_sim' + i[3:])
locSimList.append(i)
locDict[i] = sim
#translating the sim locators to their positions
pm.xform('loc_sim' + 'M',
ws=True,
translation=heightPosition['%ssim' % (charaHeight)][0],
scale=[3, 3, 3])
pm.xform('loc_sim' + 'R',
ws=True,
translation=heightPosition['%ssim' % (charaHeight)][1],
scale=[3, 3, 3])
pm.xform('loc_sim' + 'RR',
ws=True,
translation=heightPosition['%ssim' % (charaHeight)][2],
scale=[3, 3, 3])
pm.xform('loc_sim' + 'L',
ws=True,
translation=heightPosition['%ssim' % (charaHeight)][3],
scale=[3, 3, 3])
pm.xform('loc_sim' + 'LL',
ws=True,
translation=heightPosition['%ssim' % (charaHeight)][4],
scale=[3, 3, 3])
#____________________________________________________________________________________________________________________________________________________
#locList = pm.ls('locM', 'locR','locRR', 'locL', 'locLL')#recreate the list data
#locSimList = pm.ls('loc_simM', 'loc_simR','loc_simRR', 'loc_simL', 'loc_simLL')#recreating the list data
#locDict = {}
#for i in locList:
# locDict[i] = pm.ls(i[:3] + '_sim' + i[3:])
#create mantle control
mantContr = mel.eval(
'curve -d 1 -p -0.5 1 0.866025 -p 0.5 1 0.866025 -p 0.5 -1 0.866025 -p 1 -1 0 -p 1 1 0 -p 0.5 1 -0.866025 -p 0.5 -1 -0.866025 -p -0.5 -1 -0.866026 -p -0.5 1 -0.866026 -p -1 1 -1.5885e-007 -p -1 -1 -1.5885e-007 -p -0.5 -1 0.866025 -p -0.5 1 0.866025 -p -1 1 -1.5885e-007 -p -0.5 1 -0.866026 -p 0.5 1 -0.866025 -p 1 1 0 -p 0.5 1 0.866025 -p 0.5 -1 0.866025 -p -0.5 -1 0.866025 -p -1 -1 -1.5885e-007 -p -0.5 -1 -0.866026 -p 0.5 -1 -0.866025 -p 1 -1 0 -k 0 -k 1 -k 2 -k 3 -k 4 -k 5 -k 6 -k 7 -k 8 -k 9 -k 10 -k 11 -k 12 -k 13 -k 14 -k 15 -k 16 -k 17 -k 18 -k 19 -k 20 -k 21 -k 22 -k 23 -n "controller1" ;'
)
mantContr = pm.rename(mantContr, 'mantle_Control')
pm.addAttr(mantContr,
longName='Drag',
attributeType='short',
keyable=True,
defaultValue=5,
minValue=0) #adding drag attribute
pm.select(deselect=True) #deselect so it won't be the child of anything
mantleParent = pm.joint(name='mantleParent',
position=pm.xform('locM',
query=True,
worldSpace=True,
translation=True),
radius=2.5) #creating mantle parent
#main joints
jointList = {}
for i in locList:
pm.select(deselect=True) #deselect so it is parented to world
j = pm.joint(name='joint' + i[3:],
position=pm.xform(i,
query=True,
worldSpace=True,
translation=True),
radius=2.5)
jointList[j] = None
#setting transform and rotation limits
if i[2:5] == 'cR':
pm.transformLimits(j,
rotationX=[-5, 90],
rotationY=[-45, 45],
rotationZ=[-45, 25],
erx=[True, True],
ery=[True, True],
erz=[True, True])
elif i[2:5] == 'cM':
pm.transformLimits(j,
rotationX=[-5, 90],
rotationY=[-45, 45],
rotationZ=[-15, 15],
erx=[True, True],
ery=[True, True],
erz=[True, True])
elif i[2:5] == 'cL':
pm.transformLimits(j,
rotationX=[-5, 90],
rotationY=[-45, 45],
rotationZ=[-25, 45],
erx=[True, True],
ery=[True, True],
erz=[True, True])
#main sims
for i in jointList:
pm.select(i) #selecting so it is parented to parent joint
sim = pm.joint(name='sim' + i[5:],
position=pm.xform('loc_sim' + i[5:],
query=True,
worldSpace=True,
translation=True),
radius=1.5)
jointList[i] = sim
if i[5:] == 'LL' or i[5:] == 'RR':
print('re-orient' + i)
pm.joint(
i,
edit=True,
orientJoint='xyz',
secondaryAxisOrient='zup',
zeroScaleOrient=True
) #orienting joint so it move appropriately from UpperArm2
pm.select(deselect=True)
for i in jointList: #selecting joints
pm.select(i, add=True)
pm.parent(pm.ls(sl=True), mantleParent)
#calc
calcList = []
mantGroup = pm.group(name='mantleGroup', world=True,
empty=True) #creating calc joints
for i in pm.listRelatives(mantleParent):
cal = pm.duplicate(i, name=i[:7] + '_Calc', parentOnly=True)
pm.parent(cal, mantGroup)
spaceLoc = pm.spaceLocator(name='simLoc_' +
i[5:]) #creating simloc locator
pm.xform(spaceLoc,
ws=True,
translation=pm.xform(i, query=True, translation=True,
ws=True)) #moving it to the right place
pm.xform(spaceLoc, relative=True, translation=[0, -25.627, 0])
pm.addAttr(spaceLoc, longName='momentumX', attributeType='float')
pm.addAttr(spaceLoc, longName='momentumY', attributeType='float')
pm.addAttr(spaceLoc, longName='momentumZ', attributeType='float')
#creating expression to drive the SimLoc's translations
pm.expression(
object=spaceLoc,
name=spaceLoc + '_translationExp',
string=
'$f = `currentTime -q`;\n$lastposX = `getAttr -t ($f - mantle_Control.Drag) %s.translateX`;\n%s.translateX = %s.translateX - (%s.translateX - $lastposX);\n$lastposY = `getAttr -t ($f - mantle_Control.Drag) %s.translateY`;\n%s.translateY = %s.translateY - (%s.translateY - $lastposY) - 25.627;\n$lastposZ = `getAttr -t ($f - mantle_Control.Drag) %s.translateZ`;\n%s.translateZ = %s.translateZ - (%s.translateZ - $lastposZ);'
% (cal[0], spaceLoc, cal[0], cal[0], cal[0], spaceLoc, cal[0],
cal[0], cal[0], spaceLoc, cal[0], cal[0]))
'''
'$f = `currentTime -q`;\n
$lastposX = `getAttr -t ($f - mantle_Control.Drag) %s.translateX`;\n
%s.translateX = %s.translateX - (%s.translateX - $lastposX);\n
$lastposY = `getAttr -t ($f - mantle_Control.Drag) %s.translateY`;\n
%s.translateY = %s.translateY - (%s.translateY - $lastposY) - 25.627;\n
$lastposZ = `getAttr -t ($f - mantle_Control.Drag) %s.translateZ`;\n
%s.translateZ = %s.translateZ - (%s.translateZ - $lastposZ);' %(cal[0], spaceLoc, cal[0], cal[0], cal[0], spaceLoc, cal[0], cal[0], cal[0], spaceLoc, cal[0], cal[0])
'''
#create expression for the momentum attributes
if i[5:] == 'R':
xVar = '- 0.000001'
else:
xVar = '+ 0.000001'
pm.expression(
object=spaceLoc,
name=spaceLoc + '_momentumExp',
string=
'%s.momentumX = %s.translateX - %s.translateX %s;\n%s.momentumY = %s.translateY - %s.translateY;\n%s.momentumZ = %s.translateZ - %s.translateZ + 0.001;'
% (spaceLoc, cal[0], spaceLoc, xVar, spaceLoc, cal[0], spaceLoc,
spaceLoc, cal[0], spaceLoc))
'''
%s.momentumX = %s.translateX - %s.translateX %s;\n
%s.momentumY = %s.translateY - %s.translateY;\n
%s.momentumZ = %s.translateZ - %s.translateZ + 0.001;' % (spaceLoc, cal, spaceloc, xVar, spaceLoc, cal, spaceloc, spaceLoc, cal, spaceloc)
'%s.momentumX = %s.translateX - %s.translateX %s;\n%s.momentumY = %s.translateY - %s.translateY;\n%s.momentumZ = %s.translateZ - %s.translateZ + 0.001;' % (spaceLoc, cal[0], spaceLoc, xVar, spaceLoc, cal[0], spaceLoc, spaceLoc, cal[0], spaceLoc)
'''
pm.parent(spaceLoc, mantGroup)
if not cal[0][5:7] == 'RR' and not cal[0][5:7] == 'LL':
calcList.append(cal[0])
#creating transform limits for calc joints
pm.transformLimits(cal[0],
rotationX=[-5, 360],
enableRotationY=[True, False])
pm.delete(
'simLoc_RR', 'simLoc_LL', 'jointRR_Calc',
'jointLL_Calc') #deleting the RR and LL simlocs that we won't need
pm.parent(mantleParent,
'spine2') #parenting main joints into joint hierarchy
#calcDriver
calcDriver = pm.duplicate(
mantleParent, parentOnly=True,
name='mantleCalcDriver') #creating calcDriver joints
for i in pm.listRelatives(mantleParent):
j = pm.duplicate(i, name=i[:7] + '_CalcDriver', parentOnly=True)
pm.parent(j, calcDriver)
#trigo
trigoJointList = []
trigoParent = pm.duplicate(mantleParent,
parentOnly=True,
name='mantle_trigo') #creating trigoJoints
for i in pm.listRelatives(mantleParent):
trigoJoint = pm.duplicate(i, name=i[:7] + '_trigo')
sim = pm.rename(pm.listRelatives(trigoJoint[0]),
'sim' + i[5:] + '_trigo')
pm.parent(trigoJoint, trigoParent)
if not (str(trigoJoint[0][5:7]) == 'RR') and not (str(
trigoJoint[0][5:7]) == 'LL'):
trigoJointList.append(trigoJoint[0])
#creating transform limits
pm.transformLimits(trigoJoint[0],
rotationY=[-45, 45],
ery=[True, True])
if trigoJoint[0][5:7] == 'RR' or trigoJoint[0][
5:
7] == 'LL': #performing parentConstraint from upperarm2 to RR or LL joint
print('RR or LL joint constrained to upper arm')
pm.joint(
trigoJoint[0],
edit=True,
orientJoint='xyz',
secondaryAxisOrient='zup',
zeroScaleOrient=True
) #orienting joint so it move appropriately from UpperArm2
pm.parentConstraint(trigoJoint[0][5] + '_upperarm2',
trigoJoint[0],
mo=True)
#write a combined trigo expression
pm.expression(
object=trigoJointList[0],
name=trigoJointList[0] + '_trigoExp',
string=
'%s.rotateX = atand(%s.momentumZ/%s.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n%s.rotateY = atand(%s.momentumX/%s.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;\n%s.rotateX = atand(%s.momentumZ/%s.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n%s.rotateY = atand(%s.momentumX/%s.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;\n%s.rotateX = atand(%s.momentumZ/%s.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n%s.rotateY = atand(%s.momentumX/%s.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;'
% (trigoJointList[1], 'simLoc_' + trigoJointList[1][5],
'simLoc_' + trigoJointList[1][5], trigoJointList[1],
'simLoc_' + trigoJointList[1][5], 'simLoc_' + trigoJointList[1][5],
trigoJointList[0], 'simLoc_' + trigoJointList[0][5],
'simLoc_' + trigoJointList[0][5], trigoJointList[0],
'simLoc_' + trigoJointList[0][5], 'simLoc_' + trigoJointList[0][5],
trigoJointList[2], 'simLoc_' + trigoJointList[2][5],
'simLoc_' + trigoJointList[2][5], trigoJointList[2],
'simLoc_' + trigoJointList[2][5], 'simLoc_' + trigoJointList[2][5]))
'''
%s.rotateX = atand(%s.momentumZ/%s.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n
jointR_Driver1.rotateY = atand(simLocR1.momentumX/simLocR1.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;\n
jointM_Driver1.rotateX = atand(simLocM1.momentumZ/simLocM1.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n
jointM_Driver1.rotateY = atand(simLocM1.momentumX/simLocM1.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;\n
jointL_Driver1.rotateX = atand(simLocL1.momentumZ/simLocL1.momentumY) - pelvis.rotateX - spine1.rotateZ - spine2.rotateZ;\n
jointL_Driver1.rotateY = atand(simLocL1.momentumX/simLocL1.momentumZ) - pelvis.rotateY - spine1.rotateX - spine2.rotateX;\n % (trigoJointList[1], 'simLoc' + trigoJointList[1][5], 'simLoc' + trigoJointList[1][5], trigoJointList[1], 'simLoc' + trigoJointList[1][5], 'simLoc' + trigoJointList[1][5], trigoJointList[0], 'simLoc' + trigoJointList[0][5], 'simLoc' + trigoJointList[0][5], trigoJointList[0], 'simLoc' + trigoJointList[0][5], 'simLoc' + trigoJointList[0][5], trigoJointList[2], 'simLoc' + trigoJointList[2][5], 'simLoc' + trigoJointList[2][5], trigoJointList[2], 'simLoc' + trigoJointList[2][5], 'simLoc' + trigoJointList[2][5])
'''
#create the constraints for calcDriver -> calc
for i in calcList:
pm.parentConstraint(i + 'Driver', i, mo=False)
#create IK
for i in trigoJointList:
ik = pm.ikHandle(name='ikHandle' + i[5],
sj=i[:6],
ee=pm.listRelatives(i[:6])[0],
solver='ikRPsolver')[0]
pm.parent(ik, mantleParent)
pm.parentConstraint(pm.listRelatives(i)[0], ik, mo=False,
weight=1) #create constraints between trigo and IK
#if i[5] != 'M':
#pm.parentConstraint('sim' + i[5] + i[5] + '_trigo', ik, mo = True, weight = 0.25) #creating another parent constraint for the LL and RR to affect the R
pm.parentConstraint('jointRR_trigo', 'jointRR', mo=True)
pm.parentConstraint('jointLL_trigo', 'jointLL', mo=True)
pm.delete(locList, locSimList,
locDict) #deleting unnecessary stuff used to create the rig
if charaHeight == 1: #importing mantle Mesh
cmds.file(
'K:/design/maya/data/tool/scData/Mant/mantMesh/mantMesh150.ma',
i=True)
elif charaHeight == 2:
cmds.file(
'K:/design/maya/data/tool/scData/Mant/mantMesh/mantMesh160.ma',
i=True)
elif charaHeight == 3:
cmds.file(
'K:/design/maya/data/tool/scData/Mant/mantMesh/mantMesh170.ma',
i=True) #adjust address later
elif charaHeight == 4:
cmds.file(
'K:/design/maya/data/tool/scData/Mant/mantMesh/mantMesh180.ma',
i=True) #adjust address later
if not charaHeight == 0:
pm.skinCluster(pm.listRelatives(mantleParent),
mantleParent,
'mantMesh',
toSelectedBones=True)
pm.select('mantMesh')
mel.eval('source kkCharaSetup;kkCharaSetup_charaWeight_r;'
) #imports weights from data embedded inside already
def gizmoRigModules():
print 'Create gizmo rig modules'
biped = rig_biped()
biped.elbowAxis = 'ry'
biped.spine(ctrlSize=6)
biped.pelvis(ctrlSize=5)
biped.neck(ctrlSize=2.5)
biped.head(ctrlSize=5)
for side in ['l', 'r']:
armModule = biped.arm(side, ctrlSize=3)
fingersModule = biped.hand(side, ctrlSize=0.5)
shoulderModule = biped.shoulder(side, ctrlSize=2)
biped.connectArmShoulder(side)
legModule = biped.leg(side, ctrlSize=3)
toesModule = biped.foot(side, ctrlSize=0.5)
biped.connectLegPelvis()
# make tail
'''
tailModule = rig_ikChainSpline('tail', 'tailJA_JNT', ctrlSize=1, parent='pelvisJA_JNT',
numIkControls=4, numFkControls=4)
chainList = rig_chain('tailJOTip_JNT').chain
print '====== MAKING TAIL TIP =============='
fkCtrls = fkControlChain(chainList, modify=1, scale=[1, 1, 1], directCon=1)
for fk in fkCtrls:
pm.parent(fk.offset, tailModule.controls)
'''
tailModule = rig_ikChainSpline('tail',
'tailHiJA_JNT',
ctrlSize=1,
parent='pelvisJA_JNT',
numIkControls=12,
numFkControls=12)
# tail upgrade
tailJnts = pm.listRelatives('tailskeleton_GRP', type='joint')
for i in range(1, len(tailJnts)):
tailNme = tailJnts[i].stripNamespace()
tailIK = tailJnts[i]
tailFK = tailNme.replace('IK', 'FK')
tailFK = tailFK.replace('_JNT', '')
constrainObject(tailFK + 'Modify2_GRP',
[tailIK, tailFK + 'Modify1_GRP'],
tailFK + '_CTRL', ['IK', 'parent'],
type='parentConstraint')
pm.parentConstraint('tailFKACon_GRP', 'tailBaseIKOffset_GRP', mo=True)
constrainObject('tailMidAIKOffset_GRP',
['tailFKACon_GRP', 'pelvisCon_GRP', 'worldSpace_GRP'],
'tailMidAIK_CTRL', ['base', 'pelvis', 'world'],
type='parentConstraint')
constrainObject('tailMidBIKOffset_GRP', [
'tailFKACon_GRP', 'tailMidAIKCon_GRP', 'pelvisCon_GRP',
'worldSpace_GRP'
],
'tailMidBIK_CTRL', ['base', 'FK', 'pelvis', 'world'],
type='parentConstraint')
constrainObject('tailTipIKOffset_GRP', [
'tailFKACon_GRP', 'tailMidBIKCon_GRP', 'pelvisCon_GRP',
'worldSpace_GRP'
],
'tailTipIK_CTRL', ['base', 'FK', 'pelvis', 'world'],
type='parentConstraint')
tailPointer = rig_control(name='tailPointer',
shape='pyramid',
scale=(1, 2, 1),
lockHideAttrs=['rx', 'ry', 'rz'],
colour='white',
parentOffset=tailModule.controls,
rotateOrder=2)
pm.delete(pm.parentConstraint('tailHiJEnd_JNT', tailPointer.offset))
constrainObject(
tailPointer.offset,
['pelvisCon_GRP', 'spineFullBodyCon_GRP', 'worldSpace_GRP'],
tailPointer.ctrl, ['pelvis', 'fullBody', 'world'],
type='parentConstraint')
tailPointerBase = rig_transform(0,
name='tailPointerBase',
type='locator',
parent=tailModule.parts,
target='tailFKA_CTRL').object
tailPointerTip = rig_transform(0,
name='tailPointerTip',
type='locator',
parent=tailModule.parts,
target=tailPointer.con).object
pm.rotate(tailPointerBase, 0, 0, -90, r=True, os=True)
pm.rotate(tailPointerTip, 0, 0, -90, r=True, os=True)
pm.parentConstraint('pelvisCon_GRP', tailPointerBase, mo=True)
pm.parentConstraint(tailPointer.con, tailPointerTip, mo=True)
tailPointerTop = mm.eval('rig_makePiston("' + tailPointerBase + '", "' +
tailPointerTip + '", "tailPointerAim");')
pm.orientConstraint(tailPointerBase.replace('LOC', 'JNT'),
'tailFKAModify2_GRP',
mo=True)
pm.parent('tailMidAIKOffset_GRP', 'tailMidBIKOffset_GRP',
'tailTipIKOffset_GRP', tailModule.controls)
pm.parent(tailJnts, tailModule.skeleton)
pm.parent('tail_cMUS', 'tailBaseIKOffset_GRP', tailPointerTop,
tailModule.parts)
pm.setAttr(tailModule.skeleton + '.inheritsTransform', 0)
# build facial
facialModule = rig_module('facial')
pm.parent(facialModule.top, 'rigModules_GRP')
# build shape locators
for side in ['l', 'r']:
muzzleCtrl = fourWayShapeControl(
side + '_muzzleShape_LOC',
(side + 'MuzzleUp', side + 'MuzzleDown', side + 'MuzzleForward',
side + 'MuzzleBack'),
'headShapeWorld_GRP',
ctrlSize=1)
pm.rotate(muzzleCtrl.ctrl.cv, 0, 0, 90, r=True, os=True)
pm.rotate(muzzleCtrl.ctrl.cv, -45, 0, 0, r=True, os=True)
browCtrl = twoWayShapeControl(side + '_browShape_LOC',
(side + 'BrowUp', side + 'BrowDown'),
'headShapeWorld_GRP',
ctrlSize=0.8)
pm.rotate(browCtrl.ctrl.cv, 90, 0, 0, r=True, os=True)
pm.rotate(browCtrl.ctrl.cv, 0, -75, 0, r=True, os=True)
blinkCtrl = oneWayShapeControl(side + '_blinkShape_LOC',
side + 'Blink',
'headShapeWorld_GRP',
ctrlSize=0.5)
if side == 'r':
pm.rotate(blinkCtrl.ctrl.cv, 0, 0, 180, r=True, os=True)
#pm.move(blinkCtrl.ctrl.cv, 0, -0.4, 0, relative=True)
#pm.parent( muzzleCtrl.offset, browCtrl.offset , blinkCtrl.offset ,facialModule.controls)
pm.parent('headShapeWorld_GRP', facialModule.controls)
pm.parentConstraint('headJA_JNT', 'headShapeWorld_GRP')
# build simple controllers
facialLocalWorldControllers(facialModule, 'headJAWorld_GRP', ctrlSize=0.1)
pm.parentConstraint('headJA_JNT', 'headJAWorld_GRP')
pm.parent('headJAWorld_GRP', facialModule.controlsSec)
pm.move(pm.PyNode('noseTwk_CTRL').cv, 0.15, 0, 0, r=True, os=True)
pm.scale(pm.PyNode('noseTwk_CTRL').cv, 2.5, 2.5, 2.5)
# jaw control
jawControl = rig_control(name='jaw',
shape='circle',
scale=(2, 2, 2),
lockHideAttrs=['rx'],
parentOffset=facialModule.controls,
colour='white')
pm.rotate(jawControl.ctrl.cv, -90, 0, 0, r=True, os=True)
pm.move(jawControl.ctrl.cv, 2, 0, 0, r=True, os=True)
pm.delete(pm.parentConstraint('jawJA_JNT', jawControl.offset))
pm.parentConstraint('headJA_JNT', jawControl.offset, mo=True)
pm.parent('jawHeadOffset_LOC', jawControl.offset)
pm.pointConstraint(jawControl.con, 'jawHeadOffset_LOC', mo=True)
facialLoc = 'facialShapeDriver_LOC'
rig_animDrivenKey(jawControl.ctrl.rotateY, (0, 35), facialLoc + '.jawOpen',
(0, 1))
rig_animDrivenKey(jawControl.ctrl.rotateY, (0, -5),
facialLoc + '.jawClosed', (0, 1))
rig_animDrivenKey(jawControl.ctrl.rotateZ, (0, -10),
facialLoc + '.rJawSide', (0, 1))
rig_animDrivenKey(jawControl.ctrl.rotateZ, (0, 10),
facialLoc + '.lJawSide', (0, 1))
pm.transformLimits(jawControl.ctrl, ry=(-5, 35), ery=(1, 1))
pm.transformLimits(jawControl.ctrl, rz=(-10, 10), erz=(1, 1))
pm.transformLimits(jawControl.ctrl, tx=(-0.1, 0.1), etx=(1, 1))
pm.transformLimits(jawControl.ctrl, ty=(-0.1, 0.1), ety=(1, 1))
pm.transformLimits(jawControl.ctrl, tz=(0, 0.1), etz=(1, 1))
upperLipCtrls = pm.ls("*upperLip*Twk*CTRL")
for c in upperLipCtrls:
pm.scale(c.cv, 0.6, 0.6, 0.6, r=True)
pm.move(c.cv, 0, 0, 0.3, r=True)
pm.move(c.cv, 0, 0.1, 0, r=True)
lowerLipCtrls = pm.ls("*lowerLip*Twk*CTRL")
for c in lowerLipCtrls:
pm.scale(c.cv, 0.6, 0.6, 0.6, r=True)
pm.move(c.cv, 0, 0, 0.3, r=True)
pm.move(c.cv, 0, -0.1, 0, r=True)
pm.setAttr(facialModule.parts + '.inheritsTransform', 0)
pm.parent('tongueControls_GRP', facialModule.controls)
# eye controls
eyeModule = rig_module('eye')
pm.parent(eyeModule.top, 'rigModules_GRP')
eyeControl = rig_control(name='eye',
shape='circle',
modify=1,
parentOffset=eyeModule.controls,
scale=(1, 1, 1),
rotateOrder=2,
lockHideAttrs=['rx', 'ry', 'rz'])
pm.delete(pm.parentConstraint('eyeAim_LOC', eyeControl.offset))
#pm.parentConstraint( 'headCon_GRP', eyeControl.offset, mo=True )
pm.rotate(eyeControl.ctrl.cv, 90, 0, 0, r=True, os=True)
pm.select(eyeControl.ctrl.cv[1], r=True)
pm.select(eyeControl.ctrl.cv[5], add=True)
pm.scale(0, 0, 0, r=True)
constrainObject(eyeControl.offset, ['headCon_GRP', 'worldSpace_GRP'],
eyeControl.ctrl, ['head', 'world'],
type='parentConstraint')
pm.parent('eyeAim_LOC', eyeControl.con)
pm.hide('eyeAim_LOC')
for side in ('l', 'r'):
eyeBase = rig_transform(0,
name=side + '_eyeBase',
type='locator',
target=side + '_eyeJA_JNT',
parent=eyeModule.parts).object
eyeTarget = rig_transform(0,
name=side + '_eyeTarget',
type='locator',
target='eyeAim_LOC',
parent=eyeModule.parts).object
pm.parentConstraint('headJA_JNT', eyeBase, mo=True)
pm.parentConstraint('eyeAim_LOC', eyeTarget, mo=True)
eyeAimTop = mm.eval('rig_makePiston("' + eyeBase + '", "' + eyeTarget +
'", '
'"' + side + '_eyeAim");')
pm.orientConstraint(side + '_eyeBase_JNT',
side + '_eyeJA_JNT',
mo=True)
pm.parent(eyeAimTop, eyeModule.parts)
upperEyeControl = rig_control(
side=side,
name='eyeUpper',
shape='circle',
modify=1,
parentOffset=eyeModule.controlsSec,
scale=(0.1, 0.1, 0.1),
constrain=side + '_upperEyeLidRotateOffset_GRP',
rotateOrder=2,
directCon=1,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'ry'])
pm.delete(
pm.parentConstraint(side + '_eyeLocalOffset_GRP',
upperEyeControl.offset))
pm.delete(
pm.pointConstraint(side + '_eyeJA_JNT', upperEyeControl.offset))
lowerEyeControl = rig_control(
side=side,
name='eyeLower',
shape='circle',
modify=1,
parentOffset=eyeModule.controlsSec,
scale=(0.1, 0.1, 0.1),
constrain=side + '_lowerEyeLidRotateOffset_GRP',
rotateOrder=2,
directCon=1,
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'ry'])
pm.delete(
pm.parentConstraint(side + '_eyeLocalOffset_GRP',
lowerEyeControl.offset))
pm.delete(
pm.pointConstraint(side + '_eyeJA_JNT', lowerEyeControl.offset))
'''
eyeControl = rig_control(side=side, name='eye', shape='circle', modify=1,
parentOffset=eyeModule.controls, scale=(1,1,1),
rotateOrder=2, lockHideAttrs=['rx', 'ry', 'rz'])
'''
# ear controls
chainEars = rig_chain(side + '_earJA_JNT').chain
earCtrls = fkControlChain(
[side + '_earJA_JNT', side + '_earJB_JNT', side + '_earJC_JNT'],
modify=0,
scale=[0.8, 0.8, 0.8],
directCon=0)
# parent ears to headJA_JNT
for ctrl in earCtrls:
pm.parent(ctrl.parent, 'headControlsSecondary_GRP')
def camera_film_offset_tool():
"""Adds a locator to the selected camera with which you can adjust the 2d
pan and zoom.
Usage :
-------
- to add it, select the camera and use oyCameraFilmOffsetTool
- to remove it, set the transformations to 0 0 1 and then simply delete
the curve
"""
sel_list = pm.ls(sl=1)
camera_shape = ""
found_camera = 0
for obj in sel_list:
#if it is a transform node query for shapes
if isinstance(obj, pm.nt.Transform):
for shape in obj.listRelatives(s=True):
if isinstance(shape, pm.nt.Camera):
camera_shape = shape
found_camera = 1
break
elif isinstance(obj, pm.nt.Camera):
camera_shape = obj
found_camera = 1
break
if found_camera:
pass
else:
raise RuntimeError("please select one camera!")
#get the camera transform node
temp = camera_shape.listRelatives(p=True)
camera_transform = temp[0]
pm.getAttr("defaultResolution.deviceAspectRatio")
pm.getAttr("defaultResolution.pixelAspect")
#create the outer box
frame_curve = pm.curve(
d=1,
p=[(-0.5, 0.5, 0),
(0.5, 0.5, 0),
(0.5, -0.5, 0),
(-0.5, -0.5, 0),
(-0.5, 0.5, 0)],
k=[0, 1, 2, 3, 4]
)
pm.parent(frame_curve, camera_transform, r=True)
#transform the frame curve
frame_curve.tz.set(-10.0)
#create the locator
temp = pm.spaceLocator()
adj_locator = temp
adj_locator_shape = temp
adj_locator.addAttr('enable', at='bool', dv=True, k=True)
pm.parent(adj_locator, frame_curve, r=True)
pm.transformLimits(adj_locator, tx=(-0.5, 0.5), etx=(True, True))
pm.transformLimits(adj_locator, ty=(-0.5, 0.5), ety=(True, True))
pm.transformLimits(adj_locator, sx=(0.01, 2.0), esx=(True, True))
#connect the locator tx and ty to film offset x and y
adj_locator.tx >> camera_shape.pan.horizontalPan
adj_locator.ty >> camera_shape.pan.verticalPan
exp = 'float $flen = %s.focalLength;\n\n' \
'float $hfa = %s.horizontalFilmAperture * 25.4;\n' \
'%s.sx = %s.sy = -%s.translateZ * $hfa/ $flen;' % (
camera_shape, camera_shape, frame_curve, frame_curve, frame_curve)
pm.expression(s=exp, o='', ae=1, uc="all")
adj_locator.sx >> adj_locator.sy
adj_locator.sx >> adj_locator.sz
adj_locator.sx >> camera_shape.zoom
adj_locator.enable >> camera_shape.panZoomEnabled
adj_locator_shape.localScaleZ.set(0)
adj_locator.tz.set(lock=True, keyable=False)
adj_locator.rx.set(lock=True, keyable=False)
adj_locator.ry.set(lock=True, keyable=False)
adj_locator.rz.set(lock=True, keyable=False)
adj_locator.sy.set(lock=True, keyable=False)
adj_locator.sz.set(lock=True, keyable=False)
def createStereoSafePlanes(stereoCamera, base_percent=0.7, far1=0.5, far2=1.0, near1=-1.0, near2=-2.0):
if not pm.objExists(stereoCamera):
print 'Failed to find stereo camera: '+str(stereoCamera)
return []
else:
stereoCamera = pm.PyNode(stereoCamera)
try:
pm.system.loadPlugin(safePlaneNodeType, quiet=True)
except:
print traceback.format_exc()
return
safePlane = []
convergePlane = []
safePlane = [s.getParent() for s in pm.listRelatives(stereoCamera, ad=True, pa=True, type=safePlaneNodeType)]
convergePlane = [c.getParent() for c in pm.listRelatives(stereoCamera, ad=True, pa=True, type=convergePlaneNodeType)]
if safePlane and convergePlane:
return {'safePlane':safePlane[0], 'convergePlane':convergePlane[0]}
try:
if safePlane:
pm.delete(safePlane)
if convergePlane:
pm.delete(convergePlane)
except:
print traceback.format_exc()
# safe plane
safePlaneShape = pm.createNode(safePlaneNodeType)
safePlane = safePlaneShape.getParent()
stereoCameraShape = stereoCamera.getShape()
pm.transformLimits(safePlane, tz=(-999999,-0.001), etz=(False, True))
safePlane.attr('translateZ').set(-20)
safePlane.attr('translateZ') >> safePlaneShape.attr('translateZ')
stereoCameraShape.attr('cameraAperture') >> safePlaneShape.attr('filmAperture')
stereoCameraShape.attr('focalLength') >> safePlaneShape.attr('focalLength')
stereoCameraShape.attr('zeroParallax') >> safePlaneShape.attr('zeroParallax')
safePlaneShape.attr('outInterocular') >> stereoCameraShape.attr('interaxialSeparation')
for a in ['translateX', 'translateY', 'rotateX', 'rotateY', 'rotateZ', 'scaleX', 'scaleZ']:
safePlane.attr(a).lock()
safePlane.attr(a).setKeyable(False)
for a in ['localPositionX', 'localPositionY', 'localPositionZ', 'localScaleX', 'localScaleY', 'localScaleZ']:
safePlane.attr(a).setKeyable(False)
safePlane.attr(a).showInChannelBox(False)
safePlane.attr('translateZ').set(-20)
safePlaneShape.attr(safePlaneAttrMap['base']).set(base_percent)
safePlaneShape.attr(safePlaneAttrMap['farthest']).set(far2)
safePlaneShape.attr(safePlaneAttrMap['far']).set(far1)
safePlaneShape.attr(safePlaneAttrMap['near']).set(near1)
safePlaneShape.attr(safePlaneAttrMap['nearest']).set(near2)
if safePlaneShape.hasAttr('versionSwitch'):
safePlaneShape.attr('versionSwitch').set(2)
pm.parent(safePlane, stereoCamera, relative=True)
# converge plane
convergePlaneShape = pm.createNode(convergePlaneNodeType)
convergePlane = convergePlaneShape.getParent()
pm.transformLimits(convergePlane, tz=(-999999,-0.001), etz=(False, True))
convergePlane.attr('translateZ').set(-10)
convergePlane.attr('translateZ') >> convergePlaneShape.attr('translateZ')
stereoCameraShape.attr('cameraAperture') >> convergePlaneShape.attr('filmAperture')
stereoCameraShape.attr('focalLength') >> convergePlaneShape.attr('focalLength')
convergePlaneShape.attr('zeroParallax') >> stereoCameraShape.attr('zeroParallax')
for a in ['translateX', 'translateY', 'rotateX', 'rotateY', 'rotateZ', 'scaleX', 'scaleZ']:
convergePlane.attr(a).lock()
convergePlane.attr(a).setKeyable(False)
for a in ['localPositionX', 'localPositionY', 'localPositionZ', 'localScaleX', 'localScaleY', 'localScaleZ']:
convergePlane.attr(a).setKeyable(False)
convergePlane.attr(a).showInChannelBox(False)
for a in ['focalLength', 'horizontalFilmAperture', 'verticalFilmAperture', 'translateZ']:
convergePlaneShape.attr(a).setKeyable(False)
convergePlaneShape.attr(a).showInChannelBox(False)
pm.parent(convergePlane, stereoCamera, relative=True)
return {'safePlane':safePlane, 'convergePlane':convergePlane}
def limitJointsRadgoll:
import pymel.core as pm
rigname = 'female_doll'
for side in ['Right', 'Left']:
pm.transformLimits('%s_%sUpLeg'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sLeg'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sFoot'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sToeBase'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sShoulder'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sArm'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 100), rz=(-90, 90))
pm.transformLimits('%s_%sForeArm'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_%sHand'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-90, 12), rz=(-90, 90))
pm.transformLimits('%s_Spine'%(rigname, side), erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-45, 45), rz=(-90, 90))
pm.transformLimits('%s_Spine1'%rigname, erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-45, 45), rz=(-90, 90))
pm.transformLimits('%s_Spine2'%rigname, erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-12, 12), ry=(-45, 45), rz=(-90, 90))
pm.transformLimits('%s_Neck'%rigname, erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-45, 45), ry=(-45, 45), rz=(-40, 40))
pm.transformLimits('%s_Head'%rigname, erx=(1, 1), ery=(1, 1), erz=(1, 1), rx=(-45, 45), ry=(-45, 45), rz=(-90, 40))
def limitTranform(objType="nurbsCurve", limits=['t'], maxVal=1, minVal=-1):
"""transformLimit 锁定目标的移动范围
Parameters
----------
objType : str, optional
遍历物体的类型, by default "nurbsCurve"
limits : list, optional
锁定的属性 支持 ['t','r','s'], by default ['t']
maxVal : int, optional
锁定的最大值, by default 1
minVal : int, optional
锁定的最小值, by default -1
"""
sel_list = pm.ls(sl=1, dag=1, ni=1, type=objType)
for sel in sel_list:
if hasattr(sel, "getTransform"):
sel = sel.getTransform()
for limit in limits:
if limit == 't' or limit == 'translate':
pm.transformLimits(sel, tx=(minVal, maxVal), etx=(1, 0))
pm.transformLimits(sel, ty=(minVal, maxVal), ety=(1, 0))
pm.transformLimits(sel, tz=(minVal, maxVal), etz=(1, 0))
pm.transformLimits(sel, tx=(minVal, maxVal), etx=(1, 1))
pm.transformLimits(sel, ty=(minVal, maxVal), ety=(1, 1))
pm.transformLimits(sel, tz=(minVal, maxVal), etz=(1, 1))
elif limit == 'r' or limit == 'rotate':
pm.transformLimits(sel, rx=(minVal, maxVal), erx=(1, 0))
pm.transformLimits(sel, ry=(minVal, maxVal), ery=(1, 0))
pm.transformLimits(sel, rz=(minVal, maxVal), erz=(1, 0))
pm.transformLimits(sel, rx=(minVal, maxVal), erx=(1, 1))
pm.transformLimits(sel, ry=(minVal, maxVal), ery=(1, 1))
pm.transformLimits(sel, rz=(minVal, maxVal), erz=(1, 1))
elif limit == 's' or limit == 'scale':
pm.transformLimits(sel, sx=(minVal, maxVal), esx=(1, 0))
pm.transformLimits(sel, sy=(minVal, maxVal), esy=(1, 0))
pm.transformLimits(sel, sz=(minVal, maxVal), esz=(1, 0))
pm.transformLimits(sel, sx=(minVal, maxVal), esx=(1, 1))
pm.transformLimits(sel, sy=(minVal, maxVal), esy=(1, 1))
pm.transformLimits(sel, sz=(minVal, maxVal), esz=(1, 1))
def build(self,
ankle,
ball,
toe,
inner,
outer,
heel,
settingsNode=None,
blendAttr=None):
# duplicate joints
self.resultJoints = coreUtils.duplicateJoints([ankle, ball, toe],
name='%s_result_XX_jnt' %
self.name)
self.fkJoints = coreUtils.duplicateJoints([ankle, ball, toe],
name='%s_fk_XX_jnt' %
self.name)
self.ikJoints = coreUtils.duplicateJoints([ankle, ball, toe],
name='%s_ik_XX_jnt' %
self.name)
self.resultBuffer = coreUtils.addChild(
self.rigGrp, 'group', '%s_resultJoints_buffer_srt' % self.name)
coreUtils.align(self.resultBuffer, self.resultJoints[0])
self.resultJoints[0].setParent(self.resultBuffer)
self.fkBuffer = coreUtils.addChild(
self.rigGrp, 'group', '%s_fkJoints_buffer_srt' % self.name)
coreUtils.align(self.fkBuffer, self.resultJoints[0])
self.fkJoints[0].setParent(self.fkBuffer)
self.ikBuffer = coreUtils.addChild(
self.rigGrp, 'group', '%s_ikJoints_buffer_srt' % self.name)
coreUtils.align(self.ikBuffer, self.resultJoints[0])
self.ikJoints[0].setParent(self.ikBuffer)
# set up blending
if not blendAttr:
pmc.addAttr(self.mainGrp,
ln='ik_fk_blend',
at='double',
minValue=0,
maxValue=1,
k=1,
h=0)
blendAttr = self.mainGrp.ik_fk_blend
for rj, ij, fj in zip([self.resultBuffer] + self.resultJoints,
[self.ikBuffer] + self.ikJoints,
[self.fkBuffer] + self.fkJoints):
coreUtils.ikFkBlend(ij, fj, rj, blendAttr=blendAttr)
ctrlSize = coreUtils.getDistance(self.resultJoints[0],
self.resultJoints[1]) * .75
# Orientation for controls and aim constraints
axis = 'x'
aimVec = (1, 0, 0)
if self.resultJoints[1].tx.get() < 0.0:
axis = '-x'
aimVec = (-1, 0, 0)
# FK ctrl
self.toeCtrl = controls.circleBumpCtrl(axis='x',
radius=ctrlSize,
name='%s_fkToe_ctrl')
self.toeCtrlBuffer = coreUtils.addParent(self.toeCtrl,
'group',
name='%s_fkToe_buffer_srt')
coreUtils.align(self.toeCtrlBuffer, ball)
self.toeCtrlBuffer.setParent(self.interfaceGrp)
self.toeCtrl.r.connect(self.fkJoints[1].r)
self.ctrls.append(self.toeCtrl)
blendAttr.connect(self.toeCtrlBuffer.visibility)
# ik Driving structure
self.heel = coreUtils.createAlignedNode(heel, 'group',
'%s_heel_srt' % self.name)
self.heel.setParent(self.rigGrp)
self.heelBuffer = coreUtils.addParent(self.heel, 'group',
'%s_heel_buffer_srt' % self.name)
self.toe = coreUtils.createAlignedNode(toe, 'group',
'%s_toe_srt' % self.name)
self.toe.setParent(self.heel)
self.inner = coreUtils.createAlignedNode(inner, 'group',
'%s_inner_srt' % self.name)
self.inner.setParent(self.toe)
innerBuffer = coreUtils.addParent(self.inner, 'group',
'%s_inner_buffer_srt' % self.name)
self.outer = coreUtils.createAlignedNode(outer, 'group',
'%s_outer_srt' % self.name)
self.outer.setParent(self.inner)
outerBuffer = coreUtils.addParent(self.outer, 'group',
'%s_outer_buffer_srt' % self.name)
self.ballPivot = coreUtils.createAlignedNode(
ball, 'group', '%s_ballPivot_srt' % self.name)
self.ballPivot.setParent(self.outer)
coreUtils.addParent(self.ballPivot, 'group',
'%s_ballPivot_buffer_srt' % self.name)
pmc.transformLimits(self.inner, rx=(0, 0), erx=(1, 0))
pmc.transformLimits(self.outer, rx=(0, 0), erx=(0, 1))
self.ball = coreUtils.createAlignedNode(ball, 'group',
'%s_ball_srt' % self.name)
self.ball.setParent(self.ballPivot)
self.ballBuffer = coreUtils.addParent(self.ball, 'group',
'%s_ball_buffer_srt' % self.name)
self.toeWiggle = coreUtils.addChild(self.ballBuffer, 'group',
'%s_toeWiggle_srt' % self.name)
componentUtils.connectIO(self.ikBuffer, self.ball, 'ball')
# ikHandles
ballIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_ball_ikHandle' % self.name,
startJoint=self.ikJoints[0],
endEffector=self.ikJoints[1],
setupForRPsolver=1)[0]
ballIkHandle.setParent(self.ball)
toeIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_toe_ikHandle' % self.name,
startJoint=self.ikJoints[1],
endEffector=self.ikJoints[2],
setupForRPsolver=1)[0]
toeIkHandle.setParent(self.toeWiggle)
# IK driving attributes
if not settingsNode:
settingsNode = self.mainGrp
attrList = [
'heel_roll', 'heel_pivot', 'ball_roll', 'ball_pivot', 'ball_twist',
'ball_bend', 'toe_roll', 'toe_pivot', 'toe_twist', 'toe_wiggle',
'toe_bend', 'edge_roll'
]
pmc.addAttr(settingsNode,
ln='ik_foot_attributes',
k=0,
h=0,
at='enum',
enumName=' ')
pmc.setAttr(settingsNode.ik_foot_attributes, cb=1, lock=1)
for attr in attrList:
pmc.addAttr(settingsNode, ln=attr, at='double', k=1, h=0)
settingsNode.heel_roll.connect(self.heel.ry)
settingsNode.heel_pivot.connect(self.heel.rz)
settingsNode.ball_roll.connect(self.ball.ry)
settingsNode.ball_pivot.connect(self.ballPivot.rz)
settingsNode.ball_twist.connect(self.ball.rx)
settingsNode.ball_bend.connect(self.ball.rz)
settingsNode.toe_roll.connect(self.toe.ry)
settingsNode.toe_pivot.connect(self.toe.rz)
settingsNode.toe_twist.connect(self.toeWiggle.rx)
settingsNode.toe_wiggle.connect(self.toeWiggle.ry)
settingsNode.toe_bend.connect(self.toeWiggle.rz)
settingsNode.edge_roll.connect(self.inner.rx)
settingsNode.edge_roll.connect(self.outer.rx)
# Deform joints
self.dfmJoints = coreUtils.duplicateJoints([ankle, ball, toe],
name='%s_XX_dfm' %
self.name)
self.dfmBufferGrp = coreUtils.addChild(
self.deformGrp, 'group', '%s_dfmJoints_buffer_srt' % self.name)
coreUtils.align(self.dfmBufferGrp, self.resultJoints[0])
self.resultBuffer.t.connect(self.dfmBufferGrp.t)
self.resultBuffer.r.connect(self.dfmBufferGrp.r)
self.resultBuffer.s.connect(self.dfmBufferGrp.s)
self.dfmJoints[0].setParent(self.dfmBufferGrp)
for i in range(3):
self.resultJoints[i].t.connect(self.dfmJoints[i].t)
self.resultJoints[i].r.connect(self.dfmJoints[i].r)
self.resultJoints[i].s.connect(self.dfmJoints[i].s)
def rig_flexControl(name,
shapeDriverLoc,
shapes=[],
flexLoc='flexShapes_LOC',
**kwds):
scale = defaultReturn(5, 'scale', param=kwds)
shape = defaultReturn('sphere', 'shape', param=kwds)
colour = defaultReturn('red', 'colour', param=kwds)
flexCenter = rig_control(
name=name + 'FlexCenter',
shape='box',
scale=(scale, scale, scale),
colour='white',
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'ry', 'rz'])
pm.delete(pm.parentConstraint(shapeDriverLoc, flexCenter.offset))
flexCtrl = rig_control(name=name + 'Flex',
shape=shape,
scale=(scale / 2, scale / 2, scale / 2),
parentOffset=flexCenter.con,
colour=colour,
lockHideAttrs=['tx', 'tz', 'rx', 'ry', 'rz'])
pm.delete(pm.parentConstraint(flexCenter.con, flexCtrl.offset))
rig_curveBetweenTwoPoints(flexCenter.con,
flexCtrl.con,
name=name + '_curveBetween',
degree=1,
colour=colour,
parent=flexCenter.offset)
i = 0
bi = 10
for shape in shapes:
if cmds.objExists(flexLoc + '.' + shape):
rig_animDrivenKey(flexCtrl.ctrl.translateY, (0, bi),
flexLoc + '.' + shape, (0, 1))
pm.transformLimits(flexCtrl.ctrl, ty=(i, 10), ety=(i, 1))
i = -10
bi = -10
pm.setAttr(flexCenter.ctrl.overrideDisplayType, 1)
pm.select(flexCtrl.ctrl.cv[1],
flexCtrl.ctrl.cv[27],
flexCtrl.ctrl.cv[36],
flexCtrl.ctrl.cv[46],
flexCtrl.ctrl.cv[54],
r=True)
pm.move(0, 3, 0, r=True, os=True, wd=True)
pm.select(flexCtrl.ctrl.cv[22],
flexCtrl.ctrl.cv[32],
flexCtrl.ctrl.cv[41],
flexCtrl.ctrl.cv[50],
flexCtrl.ctrl.cv[61],
r=True)
pm.move(0, -1, 0, r=True, os=True, wd=True)
return (flexCenter, flexCtrl)
mantContr = pm.rename(mantContr, 'mantle_Control')
pm.addAttr(mantContr, longName = 'Drag', attributeType = 'short', keyable = True, defaultValue = 5, minValue = 0) #adding drag attribute
pm.select(deselect = True)#deselect so it won't be the child of anything
mantleParent = pm.joint(name = 'mantleParent', position = pm.xform('locM', query = True, worldSpace = True, translation = True), radius = 2.5)#creating mantle parent
#main joints
jointList = {}
for i in locList:
pm.select(deselect = True)#deselect so it is parented to world
j = pm.joint(name = 'joint' + i[3:], position = pm.xform(i, query = True, worldSpace = True, translation = True), radius = 2.5)
jointList[j] = None
#setting transform and rotation limits
if i[2:5] == 'cR':
pm.transformLimits(j, rotationX = [-5, 90], rotationY = [-45, 45], rotationZ = [-45, 35], erx = [True, True], ery = [True, True], erz = [True, True])
if i[2:5] == 'cM':
pm.transformLimits(j, rotationX = [-5, 90], rotationY = [-45, 45], rotationZ = [-15, 15], erx = [True, True], ery = [True, True], erz = [True, True])
if i[2:5] == 'cL':
pm.transformLimits(j, rotationX = [-5, 90], rotationY = [-45, 45], rotationZ = [-35, 45], erx = [True, True], ery = [True, True], erz = [True, True])
#main sims
for i in jointList:
pm.select(i) #selecting so it is parented to parent joint
sim = pm.joint(name = 'sim' + i[5:], position = pm.xform('loc_sim'+i[5:], query = True, worldSpace = True, translation = True), radius = 1.5)
jointList[i] = sim
pm.select(deselect = True)
for i in jointList: #selecting joints
pm.select(i, add = True)
def bodySimpleControls(module):
sc = simpleControls('missileJA_JNT',
colour='white',
scale=(7, 6, 8),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
missile = sc['missileJA_JNT']
pm.move(0, 2.1, 2.5, missile.ctrl.cv, os=True, r=True)
pm.addAttr(missile.ctrl,
ln='MOTION',
at='enum',
enumName='___________',
k=True)
missile.ctrl.MOTION.setLocked(True)
pm.addAttr(missile.ctrl,
longName='cockFlaps',
at='float',
k=True,
dv=0,
min=0,
max=10)
pm.addAttr(missile.ctrl,
longName='offsetLeftFlaps',
at='float',
k=True,
dv=0,
min=-10,
max=10)
pm.addAttr(missile.ctrl,
longName='offsetRightFlaps',
at='float',
k=True,
dv=0,
min=-10,
max=10)
ABC = list(string.ascii_uppercase)
missileBayJnts = []
missileBay = []
missileBayHingeJnts = []
missileBayHinge = []
missileBayFlapJnts = []
missileBayFlap = []
for i in range(0, 5):
missileBayJnts.append('missileBay' + ABC[i] + 'JA_JNT')
missileBayHingeJnts.append('missileBayHinge' + ABC[i] + 'JA_JNT')
missileBayFlapJnts.append('missileBayFlap' + ABC[i] + 'JA_JNT')
scBay = simpleControls(missileBayJnts,
colour='red',
scale=(0.3, 0.3, 0.3),
parentOffset=module.controls,
modify=3,
lockHideAttrs=['tx', 'tz', 'rx', 'ry', 'rz'])
sc = simpleControls(missileBayHingeJnts + missileBayFlapJnts,
colour='yellow',
scale=(0.1, 0.3, 0.1),
modify=3,
shape='cylinder',
parentOffset=module.controls,
lockHideAttrs=['tx', 'tz', 'ty', 'ry', 'rx'])
for i in range(0, 5):
missileBay.append(scBay[missileBayJnts[i]])
missileBayHinge.append(sc[missileBayHingeJnts[i]])
missileBayFlap.append(sc[missileBayFlapJnts[i]])
missileBayHingeMods1 = []
missileBayHingeMods2 = []
missileBayFlapMods1 = []
missileBayFlapMods2 = []
for i in range(0, 5):
pm.move(0.2, 0, 0, missileBay[i].ctrl.cv, os=True, r=True)
pm.rotate(missileBayHinge[i].ctrl.cv, -90, 0, 0, os=True, r=True)
pm.rotate(missileBayFlap[i].ctrl.cv, -90, 0, 0, os=True, r=True)
pm.transformLimits(missileBay[i].ctrl, ty=(-2.315, 0), ety=(1, 1))
pm.transformLimits(missileBayHinge[i].ctrl, rz=(0, 0), erz=(0, 1))
pm.transformLimits(missileBayFlap[i].ctrl, rz=(0, 0), erz=(0, 1))
rig_animDrivenKey(missile.ctrl.cockFlaps, (2, 10),
missileBay[i].modify[0] + '.translateY', (0, -2.315))
rig_animDrivenKey(missile.ctrl.cockFlaps, (0, 5),
missileBayHinge[i].modify[0] + '.rotateZ', (0, -45))
rig_animDrivenKey(missile.ctrl.cockFlaps, (0, 5),
missileBayFlap[i].modify[0] + '.rotateZ', (0, -45))
missileBayHingeMods1.append(missileBayHinge[i].modify[1])
missileBayHingeMods2.append(missileBayHinge[i].modify[2])
missileBayFlapMods1.append(missileBayFlap[i].modify[1])
missileBayFlapMods2.append(missileBayFlap[i].modify[2])
offsetSDKControls(missile.ctrl,
missileBayHingeMods1,
transformAttr='rz',
attr='offsetRightFlaps',
sdkVal=-45)
offsetSDKControls(missile.ctrl,
missileBayFlapMods1,
transformAttr='rz',
attr='offsetRightFlaps',
sdkVal=-45)
offsetSDKControls(missile.ctrl,
missileBayHingeMods2,
transformAttr='rz',
attr='offsetLeftFlaps',
sdkVal=-45,
reverse=1)
offsetSDKControls(missile.ctrl,
missileBayFlapMods2,
transformAttr='rz',
attr='offsetLeftFlaps',
sdkVal=-45,
reverse=1)
simpleControls('l_buckleJA_JNT',
colour='white',
scale=(2, 2, 2),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
simpleControls('radarJA_JNT',
colour='white',
scale=(6, 4, 6),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
simpleControls('securityCamJA_JNT',
colour='white',
scale=(1.5, 0.5, 1.5),
parentOffset=module.controls,
shape='cylinder',
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'])
sc = simpleControls('topHatchJA_JNT',
colour='red',
scale=(4, 0.3, 4),
parentOffset=module.controls,
shape='cylinder',
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'])
topHatch = sc['topHatchJA_JNT']
pm.move(0, 0.5, 0, topHatch.ctrl.cv, os=True, r=True)
sc = simpleControls(('cockpitTopJA_JNT', 'cockpitBottomJA_JNT'),
colour='yellow',
scale=(7, 3, 10),
parentOffset=module.controls,
shape='circle',
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
cockpitTop = sc['cockpitTopJA_JNT']
pm.move(0, 0, 10, cockpitTop.ctrl.cv, os=True, r=True)
cockpitBottom = sc['cockpitBottomJA_JNT']
pm.rotate(cockpitBottom.ctrl.cv, 40, 0, 0, os=True, r=True)
pm.scale(cockpitBottom.ctrl.cv, 1, 1, 0.6, os=True, r=True)
# engine controls
colour = 'blue'
for side in ('l', 'r'):
sc = simpleControls(side + '_engineJA_JNT',
colour='white',
scale=(4, 3, 4),
parentOffset=module.controls,
shape='cylinder',
lockHideAttrs=['tx', 'ty', 'tz', 'rx', 'rz'])
engine = sc[side + '_engineJA_JNT']
pm.addAttr(engine.ctrl,
ln='MOTION',
at='enum',
enumName='___________',
k=True)
engine.ctrl.MOTION.setLocked(True)
pm.addAttr(engine.ctrl,
longName='engineRPM',
at='float',
k=True,
dv=15)
pm.addAttr(engine.ctrl,
longName='reverseRPM',
at='long',
k=True,
dv=0,
min=0,
max=1)
pm.addAttr(engine.ctrl,
longName='rotateFlaps',
at='float',
k=True,
dv=0)
if side == 'r':
colour = 'red'
sc = simpleControls(
(side + '_engineFlapAJA_JNT', side + '_engineFlapBJA_JNT',
side + '_engineFlapCJA_JNT'),
modify=1,
colour=colour,
scale=(3, 1.5, 0.5),
parentOffset=module.controls,
lockHideAttrs=['tx', 'ty', 'tz', 'ry', 'rz'])
for jnt in sc:
engineFlap = sc[jnt]
pm.connectAttr(engine.ctrl.rotateFlaps,
engineFlap.modify + '.rotateX')
mayaTime = pm.PyNode('time1')
engineRotMD = multiplyDivideNode(side + '_engineRotate',
'multiply',
input1=[mayaTime.outTime, 0, 0],
input2=[0.25, 0, 0],
output=[])
multiplyDivideNode(side + '_engineRpm',
'multiply',
input1=[engineRotMD.outputX, 0, 0],
input2=[engine.ctrl.engineRPM, 0, 0],
output=[side + '_engineSpinJA_JNT.rotateY'])
pm.setDrivenKeyframe(engineRotMD.input2X,
cd=engine.ctrl.reverseRPM,
dv=0,
v=1)
pm.setDrivenKeyframe(engineRotMD.input2X,
cd=engine.ctrl.reverseRPM,
dv=1,
v=-1)
def removeRotLimits(node):
for child in node.getChildren():
pm.transformLimits(child, erx=(0, 0), ery=(0, 0), erz=(0, 0))
if child.numChildren() > 0:
removeRotLimits(child)
def placement(self):
grp2 = pm.ls("*offSet*")
fols = pm.ls("*_fol")
for num, fol in enumerate(fols):
pos = pm.xform(fol, query=True, worldSpace=True, translation=True)
oldName = fol.split("_")
newName = oldName[0] + "_" + oldName[1] + "_"
self.fControl(newName, num)
pm.xform(grp2, worldSpace=True, translation=pos)
loc = pm.spaceLocator(name="loc_{}".format(num))
pm.setAttr(loc + ".visibility", 0)
pm.xform(loc, worldSpace=True, translation=pos)
pm.pointConstraint(fol, loc)
pm.orientConstraint(fol, loc)
ctls = pm.ls("*fCTL", type="transform")
for x in ctls:
pm.transformLimits(x, translationX=(-1,1), enableTranslationX=(1,0))
pm.transformLimits(x, translationX=(-1,1), enableTranslationX=(1,1))
pm.transformLimits(x, translationY=(-1,1), enableTranslationY=(1,0))
pm.transformLimits(x, translationY=(-1,1), enableTranslationY=(1,1))
pm.transformLimits(x, translationZ=(-1,1), enableTranslationZ=(1,0))
pm.transformLimits(x, translationZ=(-1,1), enableTranslationZ=(1,1))
grp3 = pm.ls("*woldSpace*", type="transform")
locs = pm.ls("loc_?", "loc_??", type="transform")
for x, y in sorted(zip(grp3, locs)):
pm.parent(y,x)
grp2 = pm.ls("*offSet*")
for x, y in sorted(zip(grp2, locs)):
pm.connectAttr(y + ".translate", x + ".translate", force=True)
pm.connectAttr(y + ".rotate", x + ".rotate", force=True)
pm.group(grp3, name="bsMan_faceRig_low_control_GRP")
def buildFoot(self, ankle, foot, ball, toe, inner, outer, heel,
settingsNode, blendAttr, colour, cleanup):
# Make duplicate joint chains
self.tripleChain = systemUtils.tripleChain(joints=[ankle, foot, toe],
name=self.name,
flip=0)
ikConst_grp = coreUtils.addParent(self.tripleChain['ikChain'][0],
'group',
'%s_ikConst_GRP' % self.name)
fkConst_grp = coreUtils.addParent(self.tripleChain['fkChain'][0],
'group',
'%s_fkConst_GRP' % self.name)
resultConst_grp = coreUtils.addParent(
self.tripleChain['resultChain'][0], 'group',
'%s_resultConst_GRP' % self.name)
self.tripleChain['main_grp'].setParent(self.rig_grp)
if blendAttr:
par = pmc.parentConstraint(ikConst_grp,
fkConst_grp,
resultConst_grp,
mo=0)
attr = pmc.Attribute('%s.%sW1' % (par.name(), fkConst_grp.name()))
blendAttr.connect(attr)
attr = pmc.Attribute('%s.%sW0' % (par.name(), ikConst_grp.name()))
blend_rev = coreUtils.reverse(blendAttr,
'reverse_%s_blend, UTL' % self.name)
blend_rev.outputX.connect(attr)
for bc in self.tripleChain['blendColors']:
blendAttr.connect(bc.blender)
# Orientation for controls
axis = 'x'
if self.tripleChain['resultChain'][1].tx.get() < 0.0:
axis = '-x'
ctrlSize = coreUtils.getDistance(
self.tripleChain['resultChain'][0],
self.tripleChain['resultChain'][1]) * .5
# ikHandles
ballIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_ball_ikHandle' % self.name,
startJoint=self.tripleChain['ikChain'][0],
endEffector=self.tripleChain['ikChain'][1],
setupForRPsolver=1)[0]
ballIkHandle.setParent(self.rig_grp)
ballIkHandleConst = coreUtils.addParent(
ballIkHandle, 'group', '%s_ballIkHandle_CONST' % self.name)
toeIkHandle = pmc.ikHandle(solver='ikRPsolver',
name='%s_toe_ikHandle' % self.name,
startJoint=self.tripleChain['ikChain'][1],
endEffector=self.tripleChain['ikChain'][2],
setupForRPsolver=1)[0]
toeIkHandle.setParent(self.rig_grp)
toeIkHandleConst = coreUtils.addParent(
toeIkHandle, 'group', '%s_toeIkHandle_CONST' % self.name)
# ikCtrls
self.heelLoc = coreUtils.createAlignedNode(heel, 'group',
'%s_heel_GRP' % self.name)
self.heelLoc.setParent(self.rig_grp)
self.ikRig_grp = coreUtils.addParent(self.heelLoc, 'group',
'%s_heel_ZERO' % self.name)
self.toeLoc = coreUtils.createAlignedNode(toe, 'group',
'%s_toe_GRP' % self.name)
self.toeLoc.setParent(self.heelLoc)
self.innerLoc = coreUtils.createAlignedNode(inner, 'group',
'%s_inner_GRP' % self.name)
self.innerLoc.setParent(self.toeLoc)
innerZero = coreUtils.addParent(self.innerLoc, 'group',
'%s_inner_ZERO' % self.name)
self.outerLoc = coreUtils.createAlignedNode(outer, 'group',
'%s_outer_GRP' % self.name)
self.outerLoc.setParent(self.innerLoc)
outerZero = coreUtils.addParent(self.outerLoc, 'group',
'%s_outer_ZERO' % self.name)
self.ballPivotLoc = coreUtils.createAlignedNode(
ball, 'group', '%s_ballPivot_GRP' % self.name)
self.ballPivotLoc.setParent(self.outerLoc)
coreUtils.addParent(self.ballPivotLoc, 'group',
'%s_ballPivot_ZERO' % self.name)
pmc.transformLimits(self.innerLoc, rx=(-45, 0), erx=(0, 1))
pmc.transformLimits(self.outerLoc, rx=(0, 45), erx=(1, 0))
self.ballLoc = coreUtils.createAlignedNode(foot, 'group',
'%s_ball_GRP' % self.name)
self.ballLoc.setParent(self.ballPivotLoc)
self.ballZero = coreUtils.addParent(self.ballLoc, 'group',
'%s_ball_ZERO' % self.name)
self.toeWiggleLoc = coreUtils.addChild(self.ballZero, 'group',
'%s_toeWiggle_GRP' % self.name)
pmc.parentConstraint(self.ballLoc, ballIkHandleConst, mo=1)
pmc.parentConstraint(self.toeWiggleLoc, toeIkHandleConst, mo=1)
# driver attributes
for attrName in [
'roll_heel', 'roll_ball', 'roll_toe', 'pivot_heel',
'pivot_ball', 'pivot_toe', 'tilt_side', 'lean_ankle',
'wiggle_toe', 'lean_toe'
]:
pmc.addAttr(settingsNode, ln=attrName, at='double', k=1, h=0)
attr = pmc.Attribute('%s.roll_heel' % settingsNode.name())
attr.connect(self.heelLoc.ry)
attr = pmc.Attribute('%s.roll_ball' % settingsNode.name())
attr.connect(self.ballLoc.ry)
attr = pmc.Attribute('%s.roll_toe' % settingsNode.name())
attr.connect(self.toeLoc.ry)
attr = pmc.Attribute('%s.pivot_heel' % settingsNode.name())
attr.connect(self.heelLoc.rz)
attr = pmc.Attribute('%s.pivot_ball' % settingsNode.name())
attr.connect(self.ballPivotLoc.rz)
attr = pmc.Attribute('%s.pivot_toe' % settingsNode.name())
attr.connect(self.toeLoc.rz)
attr = pmc.Attribute('%s.tilt_side' % settingsNode.name())
attr.connect(self.innerLoc.rx)
attr.connect(self.outerLoc.rx)
attr = pmc.Attribute('%s.lean_ankle' % settingsNode.name())
attr.connect(self.ballLoc.rx)
attr = pmc.Attribute('%s.wiggle_toe' % settingsNode.name())
attr.connect(self.toeWiggleLoc.ry)
attr = pmc.Attribute('%s.lean_toe' % settingsNode.name())
attr.connect(self.toeWiggleLoc.rx)
# fkCtrl
self.ballFkCtrl = controls.pinCtrl(name='%s_ball_fk_CTRL' % self.name,
axis=axis,
radius=ctrlSize)
coreUtils.align(self.ballFkCtrl, self.tripleChain['fkChain'][1])
self.ballFkCtrl.setParent(self.ctrls_grp)
self.ballFkCtrlZero = coreUtils.addParent(
self.ballFkCtrl, 'group', '%s_ballFkCtrl_ZERO' % self.name)
pmc.parentConstraint(self.ballFkCtrl, self.tripleChain['fkChain'][1])
coreUtils.colorize(colour, [self.ballFkCtrl])
pmc.parentConstraint(self.ballFkCtrlZero, fkConst_grp, mo=1)
for joint in self.tripleChain['resultChain']:
self.joints.append(joint)
# connections
self.exposeSockets({'ikFoot': self.tripleChain['ikChain'][0]})
if cleanup:
self.cleanup()
def cyroShoulderUpgrade(side='', ctrlSize=1):
name = side + '_quadShoulder'
module = rig_module(name)
ctrlSizeHalf = [ctrlSize / 2.0, ctrlSize / 2.0, ctrlSize / 2.0]
ctrlSize = [ctrlSize, ctrlSize, ctrlSize]
shoulderControl = rig_control(side=side,
name='quadShoulder',
shape='pyramid',
targetOffset=side + '_clavicleJA_JNT',
modify=1,
parentOffset=module.controls,
lockHideAttrs=['rx', 'ry', 'rz'],
scale=ctrlSize,
rotateOrder=0)
clavPos = pm.xform(side + '_clavicleJA_JNT',
translation=True,
query=True,
ws=True)
armPos = pm.xform(side + '_scapulaJA_JNT',
translation=True,
query=True,
ws=True)
clavLength = lengthVector(armPos, clavPos)
if side == 'l':
pm.move(pm.PyNode(shoulderControl.offset),
clavLength,
0,
0,
r=True,
os=True)
else:
pm.move(pm.PyNode(shoulderControl.offset),
-1 * clavLength,
0,
0,
r=True,
os=True)
pm.rotate(pm.PyNode(shoulderControl.offset), 0, 0, -90, r=True, os=True)
pm.parentConstraint('spineJF_JNT', shoulderControl.offset, mo=True)
clavicleAim = rig_transform(0,
name=side + '_clavicleAim',
type='locator',
parent=module.parts,
target=side + '_clavicleJA_JNT').object
armAim = rig_transform(0,
name=side + '_quadShoulderAim',
type='locator',
parent=module.parts).object
pm.pointConstraint('spineJF_JNT', clavicleAim, mo=True)
pm.pointConstraint(shoulderControl.con, armAim)
quadShoulderAimTop = mm.eval('rig_makePiston("' + clavicleAim + '", "' +
armAim + '", "' + side +
'_quadShoulderAim");')
#pm.orientConstraint( clavicleAim, side+'_shoulder_CTRL', mo=True )
pm.delete(pm.listRelatives(side + '_shoulderOffset_GRP',
type='constraint'))
pm.parentConstraint(clavicleAim, side + '_shoulderOffset_GRP', mo=True)
pm.addAttr(shoulderControl.ctrl,
longName='followArm',
at='float',
k=True,
min=0,
max=10,
defaultValue=1)
pm.connectAttr(shoulderControl.ctrl.followArm,
side + '_shoulder_CTRL.followArm')
baseLimit = 15
pm.transformLimits(shoulderControl.ctrl,
tx=(-1 * baseLimit, baseLimit),
etx=(1, 1))
pm.transformLimits(shoulderControl.ctrl,
ty=(-1 * baseLimit, baseLimit),
ety=(1, 1))
pm.transformLimits(shoulderControl.ctrl,
tz=(-1 * baseLimit, baseLimit),
etz=(1, 1))
scapulaControl = rig_control(side=side,
name='quadScapula',
shape='box',
targetOffset=side + '_scapulaJEnd_JNT',
modify=1,
parentOffset=module.controls,
lockHideAttrs=['rx', 'ry', 'rz'],
scale=ctrlSize,
rotateOrder=0)
pm.delete(
pm.orientConstraint(side + '_scapulaJA_JNT', scapulaControl.offset))
scapulaAim = rig_transform(0,
name=side + '_quadScapulaAim',
type='locator',
parent=module.parts).object
scapulaEndAim = rig_transform(0,
name=side + '_quadScapulaEndAim',
type='locator',
parent=module.parts).object
pm.delete(pm.parentConstraint(side + '_scapulaJA_JNT', scapulaAim))
pm.pointConstraint(side + '_clavicleJA_JNT', scapulaAim, mo=True)
pm.pointConstraint(scapulaControl.con, scapulaEndAim)
pm.delete(pm.orientConstraint(side + '_scapulaJA_JNT', scapulaEndAim))
quadScapulaAimTop = mm.eval('rig_makePiston("' + scapulaAim + '", "' +
scapulaEndAim + '", "' + side +
'_quadScapulaAim");')
#pm.parentConstraint( side+'_clavicleJA_JNT', 'spineJE_JNT', scapulaControl.offset, mo=True )
constrainObject(scapulaControl.offset,
[side + '_clavicleJA_JNT', 'spineJE_JNT'],
'', [],
type='parentConstraint',
doSpace=0,
setVal=(0.5, 1))
baseLimit = 5
pm.transformLimits(scapulaControl.ctrl,
tx=(-1 * baseLimit, baseLimit),
etx=(1, 1))
pm.transformLimits(scapulaControl.ctrl,
ty=(-1 * baseLimit, baseLimit),
ety=(1, 1))
pm.transformLimits(scapulaControl.ctrl,
tz=(-1 * baseLimit, baseLimit),
etz=(1, 1))
pm.orientConstraint(scapulaAim, side + '_scapulaJA_JNT', mo=True)
pm.hide(side + '_shoulderOffset_GRP')
pm.parent(quadShoulderAimTop, quadScapulaAimTop, module.parts)
def build(name="", side="rt", settingsNode=""):
main_grp = pmc.group(empty=1, name=name + "_grp")
const_grp = pmc.group(empty=1, name=name + "_const_grp")
const_grp.setParent(main_grp)
const_grp.tz.set(-4)
outer_grp = pmc.group(empty=1, name=name + "_outer_grp")
outer_grp.setParent(const_grp)
outer_loc = pmc.spaceLocator(name=name + "_outer_loc")
outer_loc.setParent(outer_grp)
if side == "lf":
outer_grp.tx.set(2)
else:
outer_grp.tx.set(-2)
inner_grp = pmc.group(empty=1, name=name + "_inner_grp")
inner_grp.setParent(outer_loc)
inner_loc = pmc.spaceLocator(name=name + "_inner_loc")
inner_loc.setParent(inner_grp)
inner_grp.tx.set(outer_grp.tx.get() * -2)
heel_grp = pmc.group(empty=1, name=name + "_heel_grp")
heel_grp.setParent(inner_loc)
heel_loc = pmc.spaceLocator(name=name + "_heel_loc")
heel_loc.setParent(heel_grp)
heel_grp.tz.set(-4)
heel_grp.tx.set(inner_grp.tx.get() * -0.5)
toe_loc = pmc.spaceLocator(name=name + "_toe_loc")
toe_loc.setParent(heel_loc)
toe_loc.tz.set(8)
ballPivot_loc = pmc.spaceLocator(name=name + "_ballPivot_loc")
ballPivot_loc.setParent(toe_loc)
ballPivot_loc.tz.set(-2)
toeFlex_loc = pmc.spaceLocator(name=name + "_toeFlex_loc")
toeFlex_loc.setParent(ballPivot_loc)
toeFlex_loc.tz.set(0)
ball_loc = pmc.spaceLocator(name=name + "_ball_loc")
ball_loc.setParent(ballPivot_loc)
ball_loc.tz.set(0)
if not settingsNode:
settingsNode = main_grp
attrs = ["rock_ball", "rock_toe", "rock_side", "pivot_ball", "pivot_toe", "flex_toe", "lean"]
for attr in attrs:
pmc.addAttr(settingsNode, ln=attr, keyable=1, hidden=0)
settingsNode.rock_ball.connect(ball_loc.rx)
settingsNode.rock_toe.connect(toe_loc.rx)
settingsNode.flex_toe.connect(toeFlex_loc.rx)
if side == "rt":
settingsNode.rock_side.connect(outer_loc.rz)
settingsNode.rock_side.connect(inner_loc.rz)
pmc.transformLimits(outer_loc, rz=(0, 45), erz=(1, 0))
pmc.transformLimits(inner_loc, rz=(-45, 0), erz=(0, 1))
settingsNode.pivot_ball.connect(ballPivot_loc.ry)
settingsNode.pivot_toe.connect(toe_loc.ry)
settingsNode.lean.connect(ball_loc.rz)
else:
uc = common.convert(settingsNode.rock_side, -0.018, name + "_rock_side_uc")
uc.output.connect(outer_loc.rz)
uc.output.connect(inner_loc.rz)
pmc.transformLimits(outer_loc, rz=(-45, 0), erz=(0, 1))
pmc.transformLimits(inner_loc, rz=(0, 45), erz=(1, 0))
uc = common.convert(settingsNode.pivot_ball, -0.018, name + "_pivot_ball_uc")
uc.output.connect(ballPivot_loc.ry)
uc = common.convert(settingsNode.pivot_toe, -0.018, name + "_pivot_toe_uc")
uc.output.connect(toe_loc.ry)
uc = common.convert(settingsNode.lean, -0.018, name + "_lean_uc")
uc.output.connect(ball_loc.rz)
