def main(name="arm",
positions=None,
inheritTemplateRotations=False,
radius=1,
ikShape="cube"):
# create template joints if needed
tmp = None
if not positions:
positions = template(name=name)
tmp = positions[:] # copy
# positions/orientations from template transforms/joints
rotations = [None] * 4
for i in range(4):
if type(positions[i]) == str or type(positions[i]) == unicode:
if inheritTemplateRotations:
rotations[i] = mc.xform(positions[i], q=True, ro=True, ws=True)
positions[i] = mc.xform(positions[i], q=True, rp=True, ws=True)
grp = mc.createNode("transform", n=name)
#
# ik joints
#
ik = [None] * 4
for i in range(1, 4):
ik[i] = mc.createNode("joint", n=name + "_ik" + str(i + 1))
mc.setAttr(ik[i] + ".t", positions[i][0], positions[i][1],
positions[i][2])
if inheritTemplateRotations:
mc.setAttr(ik[i] + ".r", rotations[i][0], rotations[i][1],
rotations[i][2])
if not inheritTemplateRotations:
if positions[1][0] >= -0.001:
mc.delete(
mc.aimConstraint(ik[2],
ik[1],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[3]))
mc.delete(
mc.aimConstraint(ik[3],
ik[2],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[1]))
mc.delete(
mc.aimConstraint(ik[2],
ik[3],
aim=(-1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[1]))
else:
mc.delete(
mc.aimConstraint(ik[2],
ik[1],
aim=(-1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[3]))
mc.delete(
mc.aimConstraint(ik[3],
ik[2],
aim=(-1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[1]))
mc.delete(
mc.aimConstraint(ik[2],
ik[3],
aim=(1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[1]))
for i in range(1, 4):
r = mc.getAttr(ik[i] + ".r")[0]
mc.setAttr(ik[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(ik[i] + ".r", 0, 0, 0)
mc.setAttr(ik[i] + ".radius", radius * 0.5)
# first ik joint
ik[0] = mc.createNode("joint", n=name + "_ik1")
mc.setAttr(ik[0] + ".t", positions[0][0], positions[0][1], positions[0][2])
if inheritTemplateRotations:
mc.setAttr(ik[0] + ".r", rotations[0][0], rotations[0][1],
rotations[0][2])
else:
n = mc.createNode("transform")
mc.delete(mc.pointConstraint(ik[0], n))
mc.setAttr(n + ".tz", mc.getAttr(n + ".tz") - 1)
if positions[1][0] >= -0.001:
mc.delete(
mc.aimConstraint(ik[1],
ik[0],
aim=(1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=n))
else:
mc.delete(
mc.aimConstraint(ik[1],
ik[0],
aim=(-1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=n))
mc.delete(n)
r = mc.getAttr(ik[0] + ".r")[0]
mc.setAttr(ik[0] + ".jo", r[0], r[1], r[2])
mc.setAttr(ik[0] + ".r", 0, 0, 0)
#
# ik controls
#
ik_ctrl_grp = [None] * 3
ik_ctrl = [None] * 3
ik_ctrl_grp[1], ik_ctrl[1] = common.control(
name=name + "_ik2",
parent=grp,
position=ik[3],
normal=(1, 0, 0),
color=6,
radius=radius,
shape=ikShape,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
mc.addAttr(ik_ctrl[1], ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[1], ln="editJoints", at="bool", k=True)
mc.addAttr(ik_ctrl[1], ln="fkControls", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[1], ln="ikControls", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[1], ln="stretch", at="bool", k=True)
ik_ctrl_grp[2], ik_ctrl[2] = common.control(name=name+"_pv", parent=grp,
position=ik[2], rotation=ik[2], normal=(0,0,1),
color=6, radius=radius*0.25, shape=ikShape,
lockAttr=["r","s"], \
hideAttr=["rx","ry","rz","sx","sy","sz","v"])
if positions[0][0] <= -0.001:
mc.move(0, 0, -3 * radius, ik_ctrl_grp[2], os=True, r=True, wd=True)
else:
direction = -1 if inheritTemplateRotations else 1
mc.move(0,
0,
direction * 3 * radius,
ik_ctrl_grp[2],
os=True,
r=True,
wd=True)
mc.connectAttr(ik_ctrl[1] + ".ikControls", ik_ctrl[2] + ".v")
#
# ik stretch joints
#
ik2 = [None] * 4
for i in range(4):
ik2[i] = mc.duplicate(ik[i])[0]
ik2[i] = mc.rename(ik2[i], name + "_ik" + str(i + 1) + "_str")
if not i: ik2[i] = mc.parent(ik2[i], grp)[0]
else:
ik2[i] = mc.parent(ik2[i], ik2[i - 1])[0]
if i < 3:
c = mc.parentConstraint(ik[i], ik2[i])[0]
mc.rename(c, name + "_ik" + str(i + 1) + "_str_parcon")
else:
c = mc.pointConstraint(ik[i], ik2[i])[0]
mc.rename(c, name + "_ik" + str(i + 1) + "_str_pntcon")
if i == 2: mc.connectAttr(ik[2] + ".r", ik2[2] + ".r")
mc.setAttr(ik2[i] + ".jo", 0, 0, 0)
mc.delete(mc.orientConstraint(ik[3], ik2[3]))
c = mc.orientConstraint(ik_ctrl[1], ik2[3], mo=True)[0]
mc.rename(c, ik2[3].split("|")[-1] + "_oricon")
#
# fk joints and controls
#
fk_ctrl = [None] * 4
jnt = [None] * 4
for i in range(4):
fk_ctrl[i] = mc.duplicate(ik[i])[0]
if i:
fk_ctrl[i] = mc.rename(fk_ctrl[i],
name + "_fk" + str(i + 1) + "_ctrl")
mc.connectAttr(ik2[i] + ".t", fk_ctrl[i] + ".t")
mc.connectAttr(ik2[i] + ".r", fk_ctrl[i] + ".jo")
mc.setAttr(fk_ctrl[i] + ".r", 0, 0, 0)
if inheritTemplateRotations:
common.control(addShapeTo=fk_ctrl[i],
normal=(1, 0, 0),
color=13,
radius=radius * 0.7)
else:
common.control(addShapeTo=fk_ctrl[i],
normal=(1, 0, 0),
color=13,
radius=radius * 0.7)
mc.connectAttr(
ik_ctrl[1] + ".fkControls",
mc.listRelatives(fk_ctrl[i], pa=True, s=True)[0] + ".v")
else:
# the first fk control becomes ik one
fk_ctrl[i] = mc.rename(fk_ctrl[i], name + "_ik1_ctrl")
common.control(addShapeTo=fk_ctrl[i],
normal=(1, 0, 0),
color=6,
radius=radius)
mc.connectAttr(
ik_ctrl[1] + ".ikControls",
mc.listRelatives(fk_ctrl[i], pa=True, s=True)[0] + ".v")
if i == 1: fk_ctrl[i] = mc.parent(fk_ctrl[i], grp)[0]
elif i > 1: fk_ctrl[i] = mc.parent(fk_ctrl[i], fk_ctrl[i - 1])[0]
mc.setAttr(fk_ctrl[i] + ".drawStyle", 2)
# fk joints
jnt[i] = mc.duplicate(ik[i])[0]
if i: jnt[i] = mc.parent(jnt[i], fk_ctrl[i])[0]
else: jnt[i] = mc.parent(jnt[i], ik[0])[0]
jnt[i] = mc.rename(jnt[i], name + "_jnt" + str(i + 1))
for a in ["t", "r", "jo"]:
mc.setAttr(jnt[i] + "." + a, 0, 0, 0)
mc.connectAttr(ik_ctrl[1] + ".joints", jnt[i] + ".v")
if i: mc.setAttr(jnt[i] + ".drawStyle", 0)
mc.setAttr(jnt[i] + ".radius", radius * 0.5)
# the first ik joint becomes fk control
common.control(addShapeTo=ik[0],
normal=(1, 0, 0),
color=13,
radius=radius * 0.7)
mc.connectAttr(ik_ctrl[1] + ".fkControls",
mc.listRelatives(ik[0], pa=True, s=True)[0] + ".v")
ik[0] = mc.rename(ik[0], name + "_fk1_ctrl")
mc.setAttr(ik[0] + ".drawStyle", 2)
fk1_ctrl_grp = mc.createNode("joint", n=name + "_fk1_ctrl_grp", p=grp)
mc.delete(mc.parentConstraint(ik[0], fk1_ctrl_grp))
r = mc.getAttr(ik[0] + ".jo")[0]
mc.setAttr(fk1_ctrl_grp + ".jo", r[0], r[1], r[2])
mc.connectAttr(fk_ctrl[0] + ".r", fk1_ctrl_grp + ".r")
mc.setAttr(fk1_ctrl_grp + ".drawStyle", 2)
ik[0] = mc.parent(ik[0], fk1_ctrl_grp)[0]
mc.setAttr(ik[0] + ".jo", 0, 0, 0)
c = mc.orientConstraint(fk_ctrl[0], ik2[0], mo=True)[0]
mc.rename(c, name + "_ik" + str(i + 1) + "_str_oricon")
fk2_ctrl_grp = mc.createNode("joint", n=name + "_fk2_ctrl_grp")
mc.setAttr(fk2_ctrl_grp + ".drawStyle", 2)
#
# ik handles
#
for i in range(2, 4):
ik[i] = mc.parent(ik[i], ik[i - 1])[0]
mc.select(ik[1:])
mc.SetPreferredAngle()
ikh = common.ikHandle(name, ik[1], ik[3], parent=ik_ctrl[1])[0]
pvc = mc.poleVectorConstraint(ik_ctrl[2], ikh)[0]
mc.rename(pvc, name + "_pvcon")
#
# stretch math
#
n = mc.createNode("transform", n="str_grp", p=fk_ctrl[0])
mc.delete(mc.pointConstraint(ik[1], n))
db1 = mc.createNode("distanceBetween")
mc.connectAttr(n + ".worldMatrix", db1 + ".inMatrix1")
mc.connectAttr(ik_ctrl[1] + ".worldMatrix", db1 + ".inMatrix2")
db2 = mc.createNode("distanceBetween")
n2 = mc.duplicate(n)[0]
mc.connectAttr(n2 + ".worldMatrix", db2 + ".inMatrix1")
mc.connectAttr(ik_ctrl_grp[1] + ".worldMatrix", db2 + ".inMatrix2")
md1 = mc.createNode("multiplyDivide")
mc.setAttr(md1 + ".operation", 2)
mc.connectAttr(db1 + ".distance", md1 + ".input1X")
mc.connectAttr(db2 + ".distance", md1 + ".input2X")
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(md1 + ".outputX", md2 + ".input1X")
mc.connectAttr(ik_ctrl[1] + ".stretch", md2 + ".input2X")
c = mc.createNode("condition")
mc.setAttr(c + ".secondTerm", 1)
mc.setAttr(c + ".operation", 3)
mc.connectAttr(md1 + ".outputX", c + ".colorIfTrueR")
mc.connectAttr(md2 + ".outputX", c + ".firstTerm")
mc.connectAttr(c + ".outColorR", ik[1] + ".sx")
mc.connectAttr(c + ".outColorR", ik[2] + ".sx")
# offset the stretch group to enable full extension
# of the leg before it starts stretching
db3 = mc.createNode("distanceBetween")
mc.connectAttr(fk_ctrl[1] + ".worldMatrix", db3 + ".inMatrix1")
mc.connectAttr(fk_ctrl[2] + ".worldMatrix", db3 + ".inMatrix2")
d = mc.getAttr(db3 + ".distance")
mc.connectAttr(ik_ctrl[1] + ".worldMatrix", db3 + ".inMatrix1", f=True)
d += mc.getAttr(db3 + ".distance") - mc.getAttr(db1 + ".distance")
mc.delete(db3)
p = mc.xform(n2, q=True, rp=True, ws=True)
p2 = mc.xform(ik_ctrl[1], q=True, rp=True, ws=True)
p[0] -= p2[0]
p[1] -= p2[1]
p[2] -= p2[2]
m = math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2])
p[0] /= m
p[1] /= m
p[2] /= m
p2 = mc.getAttr(n2 + ".t")[0]
mc.setAttr(n2 + ".t", p2[0] - p[0] * d, p2[1] - p[1] * d, p2[2] - p[2] * d)
#
# lock and hide attributes
#
for i in range(4):
for a in ["tx", "ty", "tz", "sx", "sy", "sz", "v", "radius"]:
mc.setAttr(fk_ctrl[i] + "." + a, l=True, k=False, cb=False)
mc.setAttr(fk_ctrl[2] + ".rx", l=True, k=False, cb=False)
mc.setAttr(fk_ctrl[2] + ".rz", l=True, k=False, cb=False)
for a in ["tx", "ty", "tz", "sx", "sy", "sz", "v", "radius"]:
mc.setAttr(ik[0] + "." + a, l=True, k=False, cb=False)
# selection sets
ik_ctrl[0] = fk_ctrl.pop(0)
fk_ctrl.insert(0, ik.pop(0))
common.sets(name, jnt, fk_ctrl, ik_ctrl)
# selectable joints
common.selectable(ik_ctrl[1] + ".editJoints", jnt)
# fk to ik bake ready
for i in range(4):
mc.addAttr(ik_ctrl[1], ln="fk" + str(i + 1), at="message", h=True)
mc.addAttr(fk_ctrl[i], ln="fk", at="message", h=True)
mc.connectAttr(ik_ctrl[1] + ".fk" + str(i + 1), fk_ctrl[i] + ".fk")
mc.addAttr(ik_ctrl[1], ln="ik1", at="message", h=True)
mc.addAttr(ik_ctrl[0], ln="ik", at="message", h=True)
mc.connectAttr(ik_ctrl[1] + ".ik1", ik_ctrl[0] + ".ik")
mc.addAttr(ik_ctrl[1], ln="ik2", at="message", h=True)
mc.addAttr(ik_ctrl[2], ln="ik", at="message", h=True)
mc.connectAttr(ik_ctrl[1] + ".ik2", ik_ctrl[2] + ".ik")
# organize
if tmp: mc.delete(tmp)
mc.parent(fk_ctrl[1], fk2_ctrl_grp)[0]
fk2_ctrl_grp = mc.parent(fk2_ctrl_grp, fk_ctrl[0])[0]
mc.setAttr(fk2_ctrl_grp + ".t", 0, 0, 0)
mc.hide(ik[0], ik2[0])
mc.parent(ik[0], ik_ctrl[0])
mc.parent(ik_ctrl[0], grp)
mc.select(grp)
mc.dgdirty(a=True)
return grp
def main(name="head",
control=None,
parent=None,
positions=None,
radius=1,
ikControlOffset=5,
ikShape="cube"):
# create template joints if needed
tmp = None
if not positions:
positions = template(name=name)
tmp = positions[:] # copy
# positions from template transforms/joints
for i in range(3):
if type(positions[i]) == str or type(positions[i]) == unicode:
positions[i] = mc.xform(positions[i], q=True, rp=True, ws=True)
if not control:
center = [0, 0, 0]
c = len(positions)
for i in range(3):
center[0] += positions[i][0]
center[1] += positions[i][1]
center[2] += positions[i][2]
center[0] /= c
center[1] /= c
center[2] /= c
control = common.control(name=name,
position=center,
normal=(0, 1, 0),
color=17,
radius=radius * 2,
lockAttr=("v"),
hideAttr=("v"))[1]
if not parent: parent = control
if not mc.objExists(control + ".joints"):
mc.addAttr(control, ln="joints", at="bool", dv=True, k=True)
if not mc.objExists(control + ".editJoints"):
mc.addAttr(control, ln="editJoints", at="bool", k=True)
if not mc.objExists(control + ".fkControls"):
mc.addAttr(control, ln="fkControls", at="bool", dv=True, k=True)
if not mc.objExists(control + ".ikControls"):
mc.addAttr(control, ln="ikControls", at="bool", dv=True, k=True)
#
# fk controls
#
fk_ctrl_grp = [None] * 3
fk_ctrl = [None] * 3
fk_ctrl_grp[0], fk_ctrl[0] = common.control(
name=name + "_jaw_fk",
parent=control,
position=positions[0],
normal=(1, 0, 0),
color=13,
radius=radius * 0.75,
lockAttr=["t", "s", "v"],
hideAttr=["tx", "ty", "tz", "sx", "sy", "sz", "v"])
c = mc.parentConstraint(parent, fk_ctrl_grp[0], mo=True)[0]
mc.rename(c, fk_ctrl_grp[0] + "_parcon")
fk_ctrl_grp[1], fk_ctrl[1] = common.control(
name=name + "_eye_lf_fk",
parent=control,
position=positions[1],
numOffsetGroups=1,
normal=(0, 0, 1),
color=13,
radius=radius * 0.5,
lockAttr=["t", "rz", "s", "v"],
hideAttr=["tx", "ty", "tz", "rz", "sx", "sy", "sz", "v"])
mc.addAttr(fk_ctrl[1],
ln="lookAt",
at="float",
min=0,
max=10,
dv=10,
k=True)
c = mc.parentConstraint(parent, fk_ctrl_grp[1], mo=True)[0]
mc.rename(c, fk_ctrl_grp[1] + "_parcon")
fk_ctrl_grp[2], fk_ctrl[2] = common.control(
name=name + "_eye_rt_fk",
parent=control,
position=positions[2],
numOffsetGroups=1,
normal=(0, 0, 1),
color=13,
radius=radius * 0.5,
lockAttr=["t", "rz", "s", "v"],
hideAttr=["tx", "ty", "tz", "rz", "sx", "sy", "sz", "v"])
mc.addAttr(fk_ctrl[2],
ln="lookAt",
at="float",
min=0,
max=10,
dv=10,
k=True)
c = mc.parentConstraint(parent, fk_ctrl_grp[2], mo=True)[0]
mc.rename(c, fk_ctrl_grp[2] + "_parcon")
for n in fk_ctrl:
mc.connectAttr(control + ".fkControls",
mc.listRelatives(n, pa=True, s=True)[0] + ".v")
#
# fk joints
#
jnt = [None] * 3
jnt[0] = mc.createNode("joint", n="jaw_jnt", p=fk_ctrl[0])
jnt[1] = mc.createNode("joint", n="eye_lf_jnt", p=fk_ctrl[1])
jnt[2] = mc.createNode("joint", n="eye_rt_jnt", p=fk_ctrl[2])
for n in jnt:
mc.setAttr(n + ".radius", radius * 0.5)
mc.connectAttr(control + ".joints", n + ".v")
#
# ik controls
#
positions[0] = [0, 0, 0]
positions[0][0] = (positions[1][0] + positions[2][0]) * 0.5
positions[0][1] = (positions[1][1] + positions[2][1]) * 0.5
positions[0][2] = (positions[1][2] +
positions[2][2]) * 0.5 + ikControlOffset * radius
ik_ctrl_grp, ik_ctrl = common.control(name=name + "_eyes_ik",
parent=control,
position=positions[0],
normal=(0, 0, 1),
color=6,
radius=radius * 0.5,
shape=ikShape,
lockAttr=["sy", "sz", "v"],
hideAttr=["sy", "sz", "v"])
mc.connectAttr(control + ".ikControls",
mc.listRelatives(ik_ctrl, pa=True, s=True)[0] + ".v")
eye_lf_aim = mc.createNode("transform", n="eye_lf_aim", p=ik_ctrl)
mc.delete(mc.pointConstraint(jnt[1], eye_lf_aim))
mc.setAttr(eye_lf_aim + ".tz", 0)
eye_rt_aim = mc.createNode("transform", n="eye_rt_aim", p=ik_ctrl)
mc.delete(mc.pointConstraint(jnt[2], eye_rt_aim))
mc.setAttr(eye_rt_aim + ".tz", 0)
n = mc.listRelatives(fk_ctrl[1], pa=True, p=True)[0]
n2 = mc.listRelatives(mc.listRelatives(fk_ctrl[1], pa=True, p=True)[0],
pa=True,
p=True)[0]
n2 = mc.createNode("transform", n=name + "_lf_eye_base_dir", p=n2)
mc.delete(mc.parentConstraint(fk_ctrl[1], n2))
mc.setAttr(n2 + ".tz", 1)
c = mc.aimConstraint(n2,
n,
aim=(0, 0, 1),
u=(0, 1, 0),
wut="objectrotation",
wu=(0, 1, 0),
wuo=ik_ctrl,
mo=True)[0]
mc.aimConstraint(eye_lf_aim,
n,
aim=(0, 0, 1),
u=(0, 1, 0),
wut="objectrotation",
wu=(0, 1, 0),
wuo=ik_ctrl,
mo=True)
mc.setDrivenKeyframe(c + "." + n2 + "W0",
v=1,
dv=0,
cd=fk_ctrl[1] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + n2 + "W0",
v=0,
dv=10,
cd=fk_ctrl[1] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + eye_lf_aim + "W1",
v=0,
dv=0,
cd=fk_ctrl[1] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + eye_lf_aim + "W1",
v=1,
dv=10,
cd=fk_ctrl[1] + ".lookAt",
itt="linear",
ott="linear")
mc.rename(c, n + "_aimcon")
n = mc.listRelatives(fk_ctrl[2], pa=True, p=True)[0]
n2 = mc.listRelatives(mc.listRelatives(fk_ctrl[2], pa=True, p=True)[0],
pa=True,
p=True)[0]
n2 = mc.createNode("transform", n=name + "_rt_eye_base_dir", p=n2)
mc.delete(mc.parentConstraint(fk_ctrl[2], n2))
mc.setAttr(n2 + ".tz", 1)
c = mc.aimConstraint(n2,
n,
aim=(0, 0, 1),
u=(0, 1, 0),
wut="objectrotation",
wu=(0, 1, 0),
wuo=ik_ctrl,
mo=True)[0]
mc.aimConstraint(eye_rt_aim,
n,
aim=(0, 0, 1),
u=(0, 1, 0),
wut="objectrotation",
wu=(0, 1, 0),
wuo=ik_ctrl,
mo=True)
mc.setDrivenKeyframe(c + "." + n2 + "W0",
v=1,
dv=0,
cd=fk_ctrl[2] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + n2 + "W0",
v=0,
dv=10,
cd=fk_ctrl[2] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + eye_rt_aim + "W1",
v=0,
dv=0,
cd=fk_ctrl[2] + ".lookAt",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(c + "." + eye_rt_aim + "W1",
v=1,
dv=10,
cd=fk_ctrl[2] + ".lookAt",
itt="linear",
ott="linear")
mc.rename(c, n + "_aimcon")
# selection sets
common.sets(name, jnt, fk_ctrl, [ik_ctrl])
# selectable joints
common.selectable(control + ".editJoints", jnt)
if tmp: mc.delete(tmp)
mc.select(control)
mc.dgdirty(a=True)
return control
def main(name="wheel", terrain=None, radius=1, scale=1):
if terrain == None:
l = mc.ls(sl=True, o=True) or []
for n in l:
if mc.nodeType(n) == "mesh":
terrain = n
break
else:
l2 = mc.listRelatives(n, pa=True, s=True, ni=True) or []
for n2 in l2:
if mc.nodeType(n2) == "mesh":
terrain = n
break
if terrain: break
grp, ctrl = common.control(name=name+"_placer", color=6, radius=radius*3, shape="square",
hideAttr=["tx","tz","rx","ry","rz","sx","sy","sz","v"],
lockAttr=["tx","tz","rx","ry","rz","sx","sy","sz"])
grp = mc.rename(grp, name+"_grp")
susp = mc.curve(d=1, p=[(0,-0.5,0),(0,0.5,0)], k=(0,1), n=name+"_susp")
mc.setAttr(susp+".template", True)
susp = mc.parent(susp, ctrl)[0]
grp2, ctrl2 = common.control(name=name, numOffsetGroups=1, color=13, radius=radius*1.25,
normal=(1,0,0), parent=grp, lockAttr=["tx","tz","rx"],
hideAttr=["tx","tz","rx","sx","sy","sz"])
tilt = mc.listRelatives(ctrl2, pa=True, p=True)[0]
tilt = mc.rename(tilt, name+"_tilt_grp")
mc.addAttr(ctrl2, ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="editJoints", at="bool", k=True)
mc.addAttr(ctrl2, ln="placer", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="wheel", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="terrain", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="editTerrain", at="bool", dv=False, k=True)
mc.addAttr(ctrl2, ln="spin", at="double", k=True)
mc.addAttr(ctrl2, ln="tilt", at="double", dv=1, k=True)
mc.addAttr(ctrl2, ln="size", at="double", dv=1, min=0, k=True)
mc.addAttr(ctrl2, ln="terrainDetection", at="bool", dv=True, k=True)
mc.addAttr(ctrl2, ln="suspensionOffset", at="double", min=0, k=True)
mc.addAttr(ctrl2, ln="suspensionLength", at="double", dv=1, min=0, k=True)
mc.connectAttr(ctrl2+".placer", ctrl+"Shape.v")
wheel = mc.polyCylinder(h=0.5, ax=(1,0,0), sc=1, ch=False, n=name+"_pxy")[0]
mc.select(wheel+".e[0:19]", wheel+".e[20:39]")
mc.polyBevel(wheel+".e[0:39]", o=0.1, ch=False)
mc.setAttr(wheel+"Shape.overrideEnabled", True)
mc.setAttr(wheel+"Shape.overrideDisplayType", 2)
mc.setAttr(wheel+"Shape.overrideShading", 0)
mc.setAttr(wheel+"Shape.overrideColor", 1)
mc.setAttr(wheel+".castsShadows", 0)
mc.setAttr(wheel+".receiveShadows", 0)
mc.setAttr(wheel+".primaryVisibility", 0)
mc.setAttr(wheel+".visibleInReflections", 0)
mc.setAttr(wheel+".visibleInRefractions", 0)
mc.setAttr(wheel+".doubleSided", 0)
mc.connectAttr(ctrl2+".wheel", wheel+"Shape.v")
mc.parent(wheel, ctrl)
jnt = mc.createNode("joint", n=name+"_jnt", p=ctrl, ss=True)
mc.connectAttr(wheel+".t", jnt+".t")
mc.connectAttr(wheel+".r", jnt+".r")
mc.connectAttr(ctrl2+".joints", jnt+".v")
mc.setAttr(jnt+".radius", radius*0.5)
common.selectable(ctrl2+".editJoints", jnt)
common.sets("wheel", jnt, None, None)
if terrain == None:
terrain = _terrain.main(name=name, parent=grp)
mc.connectAttr(ctrl2+".terrain", terrain+".v")
r = mc.createNode("reverse", ss=True)
mc.connectAttr(ctrl2+".editTerrain", r+".inputX")
mc.connectAttr(r+".outputX", terrain+".template")
ter_ted = mc.createNode("transform", p=ctrl, n=name+"_terrain_detection", ss=True)
pc = mc.parentConstraint(ctrl2, wheel)[0]
mc.pointConstraint(susp, ter_ted)
gc = mc.geometryConstraint(terrain, ter_ted)[0]
mc.connectAttr(ctrl2+".terrainDetection", gc+"."+terrain+"W0")
susp_orig = mc.createNode("transform", p=ctrl, n=name+"_suspension_origin", ss=True)
mc.pointConstraint(ter_ted, susp_orig)
mc.geometryConstraint(susp, susp_orig)
sPntConst = mc.pointConstraint(susp_orig, grp2)[0]
mc.connectAttr(ctrl2+".suspensionOffset", susp+".ty")
mc.connectAttr(ctrl2+".suspensionLength", susp+".sy")
mc.connectAttr(ctrl2+".placer", susp+".v")
adl = mc.createNode("addDoubleLinear", ss=True)
mc.connectAttr(ctrl2+".spin", adl+".input1")
mc.connectAttr(adl+".output", pc+".target[0].targetOffsetRotateX")
adl = mc.createNode("addDoubleLinear", ss=True)
mc.connectAttr(ctrl2+".tilt", adl+".input1")
md = mc.createNode("multiplyDivide", ss=True)
mc.setAttr(md+".input2Y", -1)
mc.connectAttr(ctrl2+".size", md+".input1Y")
mc.connectAttr(md+".outputY", tilt+".rotatePivotY")
mc.connectAttr(md+".outputY", tilt+".scalePivotY")
mc.connectAttr(ctrl2+".s", wheel+".s")
mc.connectAttr(ctrl2+".size", sPntConst+".oy")
mc.connectAttr(ctrl2+".size", ctrl2+".sx")
mc.connectAttr(ctrl2+".size", ctrl2+".sy")
mc.connectAttr(ctrl2+".size", ctrl2+".sz")
mc.setAttr(ctrl2+".s", l=True)
mc.move(0, -1, 0, tilt+".scalePivot", tilt+".rotatePivot", r=True)
mc.expression(s=tilt+".rz = "+ctrl2+".ry * -"+adl+".output * 0.25", o="", ae=True, uc="all", n=name+"_wheel_exp")
common.sets("wheel", None, [ctrl, ctrl2], None)
mc.select(grp)
mc.dgdirty(a=True)
return grp, ctrl, ctrl2, wheel
def main(templateFile=None,
inheritTemplateRotations=False,
controlShapes=None,
oglControlShapes=None,
fbx=False,
scale=1,
radius=1,
numTwistJoints=4,
ikShape="cube"):
template(filepath=templateFile, scale=scale)
root.main(name="assembly", position="spine1", fbx=fbx, radius=radius)
#
# spine and head
#
spine.main(
positions=["spine1", "spine2", "spine3", "spine4", "spine5", "spine6"],
radius=radius)
mc.parent("spine", "pelvis_ctrl")
mc.parentConstraint("body_ctrl", "spine_ik2_ctrl_grp", mo=True)
mc.setAttr("spine_ik1_ctrlShape.lodVisibility", False)
mc.connectAttr("assembly.joints", "spine_ik1_ctrl.joints")
mc.setAttr("spine_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "spine_ik1_ctrl.editJoints")
mc.setAttr("spine_ik1_ctrl.editJoints", k=False)
head.main(control="spine_ik6_ctrl",
parent="spine_jnt6",
positions=["jaw", "eye_lf", "eye_rt"],
radius=radius,
ikShape=ikShape)
mc.connectAttr("assembly.joints", "spine_ik6_ctrl.joints")
mc.setAttr("spine_ik6_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "spine_ik6_ctrl.editJoints")
mc.setAttr("spine_ik6_ctrl.editJoints", k=False)
#
# legs
#
leg.main(name="leg_lf",
positions=[
"leg_lf1", "leg_lf2", "leg_lf3", "leg_lf4", "leg_lf5",
"leg_lf6"
],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("leg_lf", "cog_ctrl")
mc.parentConstraint("pelvis_ctrl", "leg_lf_ik1_grp", mo=True)
mc.connectAttr("assembly.joints", "leg_lf_ik1_ctrl.joints")
mc.setAttr("leg_lf_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "leg_lf_ik1_ctrl.editJoints")
mc.setAttr("leg_lf_ik1_ctrl.editJoints", k=False)
mc.setAttr("leg_lf_ik1_ctrl.fkControls", False)
leg.main(name="leg_rt",
positions=[
"leg_rt1", "leg_rt2", "leg_rt3", "leg_rt4", "leg_rt5",
"leg_rt6"
],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("leg_rt", "cog_ctrl")
mc.parentConstraint("pelvis_ctrl", "leg_rt_ik1_grp", mo=True)
mc.connectAttr("assembly.joints", "leg_rt_ik1_ctrl.joints")
mc.setAttr("leg_rt_ik1_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "leg_rt_ik1_ctrl.editJoints")
mc.setAttr("leg_rt_ik1_ctrl.editJoints", k=False)
mc.setAttr("leg_rt_ik1_ctrl.fkControls", False)
#
# arms
#
arm.main(name="arm_lf",
positions=["arm_lf1", "arm_lf2", "arm_lf3", "arm_lf4"],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("arm_lf", "body_ctrl")
mc.parentConstraint("spine_jnt3", "arm_lf", mo=True)
mc.connectAttr("assembly.joints", "arm_lf_ik2_ctrl.joints")
mc.setAttr("arm_lf_ik2_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "arm_lf_ik2_ctrl.editJoints")
mc.setAttr("arm_lf_ik2_ctrl.editJoints", k=False)
mc.setAttr("arm_lf_ik2_ctrl.fkControls", False)
arm.main(name="arm_rt",
positions=["arm_rt1", "arm_rt2", "arm_rt3", "arm_rt4"],
radius=radius,
ikShape=ikShape,
inheritTemplateRotations=inheritTemplateRotations)
mc.parent("arm_rt", "body_ctrl")
mc.parentConstraint("spine_jnt3", "arm_rt", mo=True)
mc.connectAttr("assembly.joints", "arm_rt_ik2_ctrl.joints")
mc.setAttr("arm_rt_ik2_ctrl.joints", k=False)
mc.connectAttr("assembly.editJoints", "arm_rt_ik2_ctrl.editJoints")
mc.setAttr("arm_rt_ik2_ctrl.editJoints", k=False)
mc.setAttr("arm_rt_ik2_ctrl.fkControls", False)
#
# hands and fingers
#
positions = []
l = mc.ls("finger_lf*_1", typ="joint") or []
for n in l:
l2 = mc.listRelatives(n, pa=True, ad=True) or []
positions.append(sorted([n] + l2))
hand.main(name="hand",
side="lf",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk4_ctrl",
radius=radius,
positions=positions,
inheritTemplateRotations=inheritTemplateRotations)
mc.setAttr("arm_lf_ik2_ctrl.fingerControls", False)
positions = []
l = mc.ls("finger_rt*_1", typ="joint") or []
for n in l:
l2 = mc.listRelatives(n, pa=True, ad=True) or []
positions.append(sorted([n] + l2))
hand.main(name="hand",
side="rt",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk4_ctrl",
radius=radius,
positions=positions,
inheritTemplateRotations=inheritTemplateRotations)
mc.setAttr("arm_rt_ik2_ctrl.fingerControls", False)
#
# delete template
#
mc.delete("template")
#
# twist joints
#
if numTwistJoints:
twist.main(name="leg_lf_up",
control="leg_lf_ik1_ctrl",
parent="leg_lf_ik1_grp",
count=numTwistJoints,
stable="leg_lf_fk1_ctrl",
_twist="leg_lf_fk2_ctrl",
scale="leg_lf_ik1",
wu=(1, 0, 0),
wuo="leg_lf")
mc.delete("leg_lf_jnt1")
twist.main(name="leg_rt_up",
control="leg_rt_ik1_ctrl",
parent="leg_rt_ik1_grp",
count=numTwistJoints,
stable="leg_rt_fk1_ctrl",
_twist="leg_rt_fk2_ctrl",
scale="leg_rt_ik1",
wu=(1, 0, 0),
wuo="leg_rt")
mc.delete("leg_rt_jnt1")
twist.main(name="leg_lf_lo",
control="leg_lf_ik1_ctrl",
parent="leg_lf_fk2_ctrl",
count=numTwistJoints,
stable="leg_lf_fk2_ctrl",
_twist="leg_lf_fk3_ctrl",
scale="leg_lf_ik1")
mc.delete("leg_lf_jnt2")
twist.main(name="leg_rt_lo",
control="leg_rt_ik1_ctrl",
parent="leg_rt_fk2_ctrl",
count=numTwistJoints,
stable="leg_rt_fk2_ctrl",
_twist="leg_rt_fk3_ctrl",
scale="leg_rt_ik1")
mc.delete("leg_rt_jnt2")
twist.main(name="arm_lf_up",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk1_ctrl",
count=numTwistJoints,
stable="arm_lf_fk2_ctrl",
_twist="arm_lf_fk3_ctrl",
scale="arm_lf_ik2")
mc.delete("arm_lf_jnt2")
twist.main(name="arm_rt_up",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk1_ctrl",
count=numTwistJoints,
stable="arm_rt_fk2_ctrl",
_twist="arm_rt_fk3_ctrl",
scale="arm_rt_ik2",
aim=(-1, 0, 0))
mc.delete("arm_rt_jnt2")
twist.main(name="arm_lf_lo",
control="arm_lf_ik2_ctrl",
parent="arm_lf_fk3_ctrl",
count=numTwistJoints,
stable="arm_lf_fk3_ctrl",
_twist="arm_lf_fk4_ctrl",
scale="arm_lf_ik2")
mc.delete("arm_lf_jnt3")
twist.main(name="arm_rt_lo",
control="arm_rt_ik2_ctrl",
parent="arm_rt_fk3_ctrl",
count=numTwistJoints,
stable="arm_rt_fk3_ctrl",
_twist="arm_rt_fk4_ctrl",
scale="arm_rt_ik2",
aim=(-1, 0, 0))
mc.delete("arm_rt_jnt3")
#
# transformation spaces for some controls
#
common.space("leg_lf_ik1_ctrl",
"leg_lf_ik1_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_lf_ik1_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_lf_ik1_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("leg_lf_ik1_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_rt_ik1_ctrl",
"leg_rt_ik1_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_rt_ik1_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_rt_ik1_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("leg_rt_ik1_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_lf_pv_ctrl",
"leg_lf_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_lf_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("leg_lf_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("leg_rt_pv_ctrl",
"leg_rt_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("leg_rt_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("leg_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("leg_rt_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("spine_ik3_ctrl",
"spine_ik3_ctrl_grp",
constraint="parent",
name="local")
common.space("spine_ik3_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("spine_ik3_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("spine_ik3_ctrl",
"world_ctrl",
constraint="parent",
name="world")
common.space("arm_lf_pv_ctrl",
"arm_lf_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_lf_pv_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_lf_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("arm_lf_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_lf_pv_ctrl.space", 3)
common.space("arm_rt_pv_ctrl",
"arm_rt_pv_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_rt_pv_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_rt_pv_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog")
common.space("arm_rt_pv_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_rt_pv_ctrl.space", 3)
common.space("arm_lf_ik2_ctrl",
"arm_lf_ik2_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_lf_ik2_ctrl",
"spine_jnt6",
constraint="parent",
name="head")
common.space("arm_lf_ik2_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_lf_ik2_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_lf_ik2_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("arm_lf_ik2_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_lf_ik2_ctrl.space", 4)
common.space("arm_rt_ik2_ctrl",
"arm_rt_ik2_ctrl_grp",
constraint="parent",
name="local")
common.space("arm_rt_ik2_ctrl",
"spine_jnt6",
constraint="parent",
name="head")
common.space("arm_rt_ik2_ctrl",
"spine_jnt3",
constraint="parent",
name="chest")
common.space("arm_rt_ik2_ctrl",
"body_ctrl",
constraint="parent",
name="body")
common.space("arm_rt_ik2_ctrl",
"cog_ctrl",
constraint="parent",
name="cog")
common.space("arm_rt_ik2_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("arm_rt_ik2_ctrl.space", 4)
common.space("spine_ik6_ctrl",
"spine_ik6_ctrl_grp",
constraint="orient",
name="local")
common.space("spine_ik6_ctrl",
"spine_jnt3",
constraint="orient",
name="chest")
common.space("spine_ik6_ctrl",
"body_ctrl",
constraint="orient",
name="body")
common.space("spine_ik6_ctrl", "cog_ctrl", constraint="orient", name="cog")
common.space("spine_ik6_ctrl",
"world_ctrl",
constraint="orient",
name="world")
mc.setAttr("spine_ik6_ctrl.space", 3)
common.space("head_eyes_ik_ctrl",
"spine_ik6_ctrl",
constraint="parent",
name="local")
common.space("head_eyes_ik_ctrl",
"world_ctrl",
constraint="parent",
name="world")
mc.setAttr("head_eyes_ik_ctrl.space", 1)
#
# global switch for control visibility
#
for n in ["fk_controls_set", "ik_controls_set"]:
for n2 in mc.sets(n, q=True):
if mc.nodeType(n2) == "objectSet": l = mc.sets(n2, q=True)
else: l = [n2]
for n3 in l:
n3 = mc.listRelatives(n3, pa=True, s=True)[0]
mc.setAttr(n3 + ".overrideEnabled", True)
try:
mc.connectAttr("assembly.controls",
n3 + ".overrideVisibility")
except:
pass
#
# fbx skeleton
#
if fbx:
mc.createNode("joint", n="root_fbx", p="skeleton_fbx")
mc.setAttr("root_fbx.radius", radius * 0.25)
c = mc.pointConstraint("pelvis_ctrl", "root_fbx", sk=["y"])[0]
mc.parent(c, "constraints_fbx")
c = mc.orientConstraint("pelvis_ctrl", "root_fbx", sk=["x", "z"])[0]
mc.parent(c, "constraints_fbx")
c = mc.scaleConstraint("pelvis_ctrl", "root_fbx")[0]
mc.parent(c, "constraints_fbx")
l = [
None, "pelvis_ctrl", "spine_jnt1", "spine_jnt2", "spine_jnt3",
"spine_jnt4", "spine_jnt5", "spine_jnt6", "jaw_jnt"
]
l2 = [
"root_fbx", "pelvis_fbx", "spine_fbx1", "spine_fbx2", "spine_fbx3",
"spine_fbx4", "spine_fbx5", "spine_fbx6", "jaw_fbx"
]
for i in range(1, len(l)):
mc.createNode("joint", n=l2[i], p=l2[i - 1])
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.pointConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
c = mc.orientConstraint(l[i], l2[i], mo=True)[0]
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(c + ".o", -r[0], -r[1], -r[2])
mc.parent(c, "constraints_fbx")
for side in ["lf", "rt"]:
mc.createNode("joint", n="eye_" + side + "_fbx", p="spine_fbx6")
mc.setAttr("eye_" + side + "_fbx" + ".radius", radius * 0.25)
mc.delete(
mc.parentConstraint("eye_" + side + "_jnt",
"eye_" + side + "_fbx"))
r = mc.getAttr("eye_" + side + "_fbx.r")[0]
mc.setAttr("eye_" + side + "_fbx.jo", r[0], r[1], r[2])
mc.setAttr("eye_" + side + "_fbx.r", 0, 0, 0)
c = mc.parentConstraint("eye_" + side + "_jnt",
"eye_" + side + "_fbx",
mo=True)[0]
mc.parent(c, "constraints_fbx")
mc.duplicate("eye_" + side + "_fbx")
mc.parent("eye_" + side + "_fbx1", "eye_" + side + "_fbx")
mc.duplicate("eye_" + side + "_fbx1")
mc.parent("eye_" + side + "_fbx2", "eye_" + side + "_fbx1")
if numTwistJoints:
l = [
"leg_" + side + "_up_twr1", "leg_" + side + "_up_tw1",
"leg_" + side + "_up_tw2", "leg_" + side + "_up_tw3",
"leg_" + side + "_lo_twr1", "leg_" + side + "_lo_tw1",
"leg_" + side + "_lo_tw2", "leg_" + side + "_lo_tw3",
"leg_" + side + "_jnt3", "leg_" + side + "_jnt4"
]
l2 = [
"leg_" + side + "_tw_fbx1", "leg_" + side + "_tw_fbx2",
"leg_" + side + "_tw_fbx3", "leg_" + side + "_tw_fbx4",
"leg_" + side + "_tw_fbx5", "leg_" + side + "_tw_fbx6",
"leg_" + side + "_tw_fbx7", "leg_" + side + "_tw_fbx8",
"leg_" + side + "_fbx1", "leg_" + side + "_fbx4"
]
last_good = "pelvis_fbx"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
l = [
"arm_" + side + "_jnt1", "arm_" + side + "_up_twr1",
"arm_" + side + "_up_tw1", "arm_" + side + "_up_tw2",
"arm_" + side + "_up_tw3", "arm_" + side + "_lo_twr1",
"arm_" + side + "_lo_tw1", "arm_" + side + "_lo_tw2",
"arm_" + side + "_lo_tw3", "arm_" + side + "_jnt4"
]
l2 = [
"arm_" + side + "_fbx1", "arm_" + side + "_tw_fbx1",
"arm_" + side + "_tw_fbx2", "arm_" + side + "_tw_fbx3",
"arm_" + side + "_tw_fbx4", "arm_" + side + "_tw_fbx5",
"arm_" + side + "_tw_fbx6", "arm_" + side + "_tw_fbx7",
"arm_" + side + "_tw_fbx8", "arm_" + side + "_fbx4"
]
last_good = "spine_fbx3"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
else:
l = [
"leg_" + side + "_jnt1", "leg_" + side + "_jnt2",
"leg_" + side + "_jnt3", "leg_" + side + "_jnt4"
]
l2 = [
"leg_" + side + "_fbx1", "leg_" + side + "_fbx2",
"leg_" + side + "_fbx3", "leg_" + side + "_fbx4"
]
last_good = "pelvis_fbx"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
l = [
"arm_" + side + "_jnt1", "arm_" + side + "_jnt2",
"arm_" + side + "_jnt3", "arm_" + side + "_jnt4"
]
l2 = [
"arm_" + side + "_fbx1", "arm_" + side + "_fbx2",
"arm_" + side + "_fbx3", "arm_" + side + "_fbx4"
]
last_good = "spine_fbx3"
for i in range(0, len(l)):
if not mc.objExists(l[i]): continue
mc.createNode("joint", n=l2[i], p=last_good)
last_good = l2[i]
mc.setAttr(l2[i] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[i], l2[i]))
r = mc.getAttr(l2[i] + ".r")[0]
mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[i] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[i], l2[i], mo=True)[0]
mc.parent(c, "constraints_fbx")
for i in range(1, 6):
l = [None] + mc.ls("finger_" + side + str(i) + "_jnt*",
typ="joint") or []
l2 = ["arm_" + side + "_fbx4"] + [
"finger_" + side + str(i) + "_fbx" + str(j + 1)
for j in range(len(l) - 1)
]
for j in range(1, len(l)):
mc.createNode("joint", n=l2[j], p=l2[j - 1])
mc.setAttr(l2[j] + ".radius", radius * 0.25)
mc.delete(mc.parentConstraint(l[j], l2[j]))
r = mc.getAttr(l2[j] + ".r")[0]
mc.setAttr(l2[j] + ".jo", r[0], r[1], r[2])
mc.setAttr(l2[j] + ".r", 0, 0, 0)
c = mc.parentConstraint(l[j], l2[j], mo=True)[0]
mc.parent(c, "constraints_fbx")
mc.createNode("joint",
n="props_" + side + "_fbx",
p="arm_" + side + "_fbx4")
mc.setAttr("props_" + side + "_fbx.radius", radius * 0.25)
if side == "lf": mc.setAttr("props_" + side + "_fbx.ty", scale)
else: mc.setAttr("props_" + side + "_fbx.ty", -scale)
common.control(name="props_"+side, parent="arm_"+side+"_fk4_ctrl", \
position="props_"+side+"_fbx", rotation="props_"+side+"_fbx", \
normal=(0,1,0), color=13, radius=radius*0.5, hideAttr=["v"])
mc.addAttr("arm_" + side + "_ik2_ctrl",
ln="propsControls",
at="bool",
k=True)
mc.connectAttr("arm_" + side + "_ik2_ctrl.propsControls",
"props_" + side + "_ctrl.v")
mc.delete(
mc.parentConstraint("props_" + side + "_ctrl",
"props_" + side + "_fbx"))
r = mc.getAttr("props_" + side + "_fbx.r")[0]
mc.setAttr("props_" + side + "_fbx.jo", r[0], r[1], r[2])
mc.setAttr("props_" + side + "_fbx.r", 0, 0, 0)
c = mc.parentConstraint("props_" + side + "_ctrl",
"props_" + side + "_fbx",
mo=True)[0]
c = mc.rename(c, "props_" + side + "_fbx_parcon")
mc.parent(c, "constraints_fbx")
#
# rename controls for nice
#
mc.rename("leg_lf_ik1_ctrl", "leg_lf_ik_ctrl")
mc.rename("leg_lf_fk1_ctrl", "leg_up_lf_fk_ctrl")
mc.rename("leg_lf_fk2_ctrl", "leg_lo_lf_fk_ctrl")
mc.rename("leg_lf_fk3_ctrl", "ankle_lf_fk_ctrl")
mc.rename("leg_lf_fk4_ctrl", "toes_lf_fk_ctrl")
mc.rename("leg_rt_ik1_ctrl", "leg_rt_ik_ctrl")
mc.rename("leg_rt_fk1_ctrl", "leg_up_rt_fk_ctrl")
mc.rename("leg_rt_fk2_ctrl", "leg_lo_rt_fk_ctrl")
mc.rename("leg_rt_fk3_ctrl", "ankle_rt_fk_ctrl")
mc.rename("leg_rt_fk4_ctrl", "toes_rt_fk_ctrl")
mc.rename("spine_ik2_ctrl", "waist_ctrl")
mc.rename("spine_ik3_ctrl", "chest_ctrl")
mc.rename("spine_ik5_ctrl", "neck_ctrl")
mc.rename("spine_ik6_ctrl", "head_ctrl")
mc.rename("arm_lf_ik1_ctrl", "shoulder_lf_ik_ctrl")
mc.rename("arm_lf_ik2_ctrl", "arm_lf_ik_ctrl")
mc.rename("arm_lf_fk1_ctrl", "shoulder_lf_fk_ctrl")
mc.rename("arm_lf_fk2_ctrl", "arm_up_lf_fk_ctrl")
mc.rename("arm_lf_fk3_ctrl", "arm_lo_lf_fk_ctrl")
mc.rename("arm_lf_fk4_ctrl", "wrist_lf_fk_ctrl")
mc.rename("arm_rt_ik1_ctrl", "shoulder_rt_ik_ctrl")
mc.rename("arm_rt_ik2_ctrl", "arm_rt_ik_ctrl")
mc.rename("arm_rt_fk1_ctrl", "shoulder_rt_fk_ctrl")
mc.rename("arm_rt_fk2_ctrl", "arm_up_rt_fk_ctrl")
mc.rename("arm_rt_fk3_ctrl", "arm_lo_rt_fk_ctrl")
mc.rename("arm_rt_fk4_ctrl", "wrist_rt_fk_ctrl")
#
# load control shapes
#
if controlShapes:
if os.path.isfile(THIS_DIR + "/" + controlShapes):
common.loadControlShapes(THIS_DIR + "/" + controlShapes)
elif os.path.isfile(controlShapes):
common.loadControlShapes(controlShapes)
#
# load OpenGL shapes
#
if oglControlShapes:
f = None
if os.path.isfile(THIS_DIR + "/" + oglControlShapes):
f = THIS_DIR + "/" + oglControlShapes
elif os.path.isfile(oglControlShapes):
f = oglControlShapes
if f:
# delete wire control shapes
l = []
for t in ["fk", "ik"]:
for n in mc.sets(t + "_controls_set", q=True):
if mc.nodeType(n) != "objectSet": l.append(n)
else: l += mc.sets(n, q=True)
for n in l:
mc.delete(mc.listRelatives(n, pa=True, s=True))
# create OpenGL control shapes
f2 = open(f)
s = f2.read()
f2.close()
mm.eval(s)
# connect OpenGL shape visibility attributes to rig parameters
f = mc.internalVar(userScriptDir=True) + "/icons.cfg"
for n in l:
try:
n2 = mc.listRelatives(n, pa=True, s=True)[0]
except:
continue
mc.setAttr(n2 + ".overrideEnabled", True)
mc.connectAttr("assembly.controls", n2 + ".overrideVisibility")
mc.setAttr(n + ".iconsConfigFile", f, typ="string")
mc.setAttr(n + ".reloadIconsData", True)
for side in ["lf", "rt"]:
for n in [
"shoulder_" + side + "_fk_ctrl",
"arm_up_" + side + "_fk_ctrl",
"arm_lo_" + side + "_fk_ctrl",
"wrist_" + side + "_fk_ctrl"
]:
mc.connectAttr("arm_" + side + "_ik_ctrl.fkControls",
n + "Shape.v")
for n in [
"shoulder_" + side + "_ik_ctrl",
"arm_" + side + "_pv_ctrl", "lines_arm_" + side
]:
mc.connectAttr("arm_" + side + "_ik_ctrl.ikControls",
n + "Shape.v")
for i in ["1", "2", "3", "4", "5"]:
for j in ["1", "2", "3"]:
mc.connectAttr(
"arm_" + side + "_ik_ctrl.fingerControls",
"finger_" + side + i + "_fk" + j + "_ctrlShape.v")
for n in [
"leg_up_" + side + "_fk_ctrl",
"leg_lo_" + side + "_fk_ctrl",
"ankle_" + side + "_fk_ctrl",
"toes_" + side + "_fk_ctrl"
]:
mc.connectAttr("leg_" + side + "_ik_ctrl.fkControls",
n + "Shape.v")
for n in ["leg_" + side + "_pv_ctrl", "lines_leg_" + side]:
mc.connectAttr("leg_" + side + "_ik_ctrl.ikControls",
n + "Shape.v")
for n in ["lines_arm_" + side, "lines_leg_" + side]:
mc.connectAttr("assembly.controls",
n + "Shape.overrideVisibility")
for n in [
"head_jaw_fk_ctrl", "head_eye_rt_fk_ctrl",
"head_eye_lf_fk_ctrl"
]:
mc.connectAttr("head_ctrl.fkControls", n + "Shape.v")
mc.connectAttr("head_ctrl.ikControls", "head_eyes_ik_ctrlShape.v")
mc.connectAttr("head_ctrl.ikControls", "lines_eyesShape.v")
mc.connectAttr("assembly.controls",
"lines_eyesShape.overrideVisibility")
mc.connectAttr("assembly.controls",
"lines_spineShape.overrideVisibility")
mc.parent("lines", "lines_arm_lf", "lines_arm_rt", "lines_leg_lf",
"lines_leg_rt", "lines_eyes", "lines_spine", "assembly")
mc.setAttr("assembly.joints", False)
try:
mc.setAttr("assembly.fbxJoints", False)
except:
pass
mc.select(cl=True)
mc.dgdirty(a=True)
def main(name="spine", positions=None, radius=1):
# create template joints if needed
tmp = None
if not positions:
positions = template()
tmp = positions[:] # copy
# positions from template transforms/joints
for i in range(6):
if type(positions[i]) == str or type(positions[i]) == unicode:
positions[i] = mc.xform(positions[i], q=True, rp=True, ws=True)
grp = mc.createNode("transform", n=name)
#
# joints, part 1
#
ik = [None] * 9
mc.select(cl=True)
ik[0] = mc.joint(p=positions[0], n=name + "_ik1_off")
ik[2] = mc.joint(p=positions[1], n=name + "_ik2")
mc.joint(ik[0], e=True, oj="xyz", sao="xup", ch=False, zso=True)
# insert an "offset" joint for proper ik spline twist
ik[3] = mc.joint(p=[i * 0.5 for i in map(add, positions[1], positions[2])],
n=name + "_ik3_off")
mc.joint(ik[2], e=True, oj="xyz", sao="xup", ch=False, zso=True)
ik[4] = mc.joint(p=positions[2], n=name + "_ik3")
mc.joint(ik[3], e=True, oj="xyz", sao="xup", ch=False, zso=True)
ik[5] = mc.joint(p=positions[3], n=name + "_ik4")
mc.joint(ik[4], e=True, oj="xyz", sao="xup", ch=False, zso=True)
ik[6] = mc.joint(p=positions[4], n=name + "_ik5")
mc.joint(ik[5], e=True, oj="xyz", sao="xup", ch=False, zso=True)
mc.setAttr(ik[6] + ".jo", 0, 0, 0)
# insert an "offset" joint for proper ik spline twist
ik[7] = mc.joint(p=[i * 0.5 for i in map(add, positions[4], positions[5])],
n=name + "_ik6_off")
mc.joint(ik[6], e=True, oj="xyz", sao="xup", ch=False, zso=True)
ik[8] = mc.joint(p=positions[5], n=name + "_ik6")
mc.joint(ik[7], e=True, oj="xyz", sao="xup", ch=False, zso=True)
ik[1] = mc.duplicate(ik[0])[0]
ik[1] = mc.rename(ik[1], name + "_ik1")
mc.delete(mc.listRelatives(ik[1], pa=True, ad=True))
ik[1] = mc.parent(ik[1], ik[0])[0]
for n in ik:
mc.setAttr(n + ".radius", radius * 0.5)
for n in [ik[0], ik[3], ik[7]]:
mc.setAttr(n + ".drawStyle", 2)
#
# controls
#
ctrl_grp = [None] * 5
ctrl = [None] * 5
ctrl_grp[0], ctrl[0] = common.control(name=name + "_ik1",
parent=grp,
position=ik[0],
radius=radius * 2,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
mc.addAttr(ctrl[0], ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ctrl[0], ln="editJoints", at="bool", k=True)
ctrl_grp[1], ctrl[1] = common.control(name=name + "_ik2",
parent=ctrl[0],
position=ik[2],
radius=radius * 2,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
ctrl_grp[2], ctrl[2] = common.control(name=name + "_ik3",
parent=ctrl[1],
position=ik[4],
radius=radius * 2,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
mc.addAttr(ctrl[2], ln="stretchAbove", at="bool", k=True)
mc.addAttr(ctrl[2], ln="stretchBelow", at="bool", k=True)
ctrl_grp[3], ctrl[3] = common.control(name=name + "_ik5",
parent=ctrl[2],
position=ik[6],
radius=radius,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
anchor = mc.createNode("transform", n="spine_ik4_anchor", p=ik[4])
mc.delete(mc.parentConstraint(ik[5], anchor))
c = mc.parentConstraint(anchor, ctrl_grp[3], mo=True)[0]
mc.rename(c, ctrl_grp[3] + "_parcon")
ctrl_grp[4], ctrl[4] = common.control(name=name + "_ik6",
parent=ctrl[3],
position=ik[8],
radius=radius,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
mc.addAttr(ctrl[4], ln="stretch", at="bool", k=True)
md = mc.createNode("multiplyDivide")
mc.setAttr(md + ".operation", 2)
mc.setAttr(md + ".input1X", 1)
mc.connectAttr(ik[4] + ".sx", md + ".input2X")
mc.connectAttr(md + ".outputX", anchor + ".sx")
#
# joints, part 2
#
c = mc.orientConstraint(ctrl[2], ik[4], mo=True)[0]
mc.rename(c, ik[4] + "_oricon")
#
# ik handles
#
mc.select(ik[0], ik[4])
ikh, eff, crv = mc.ikHandle(sol="ikSplineSolver")
crv = mc.parent(crv, grp)[0]
mc.setAttr(crv + ".it", False)
mc.setAttr(ikh + ".dTwistControlEnable", True)
mc.setAttr(ikh + ".dWorldUpType", 4)
mc.setAttr(ikh + ".dWorldUpAxis", 3)
mc.setAttr(ikh + ".dWorldUpVector", 0, 0, -1)
mc.setAttr(ikh + ".dWorldUpVectorEnd", 0, 0, -1)
ikh = mc.parent(ikh, grp)[0]
mc.hide(ikh, crv)
ikh = mc.rename(ikh, name + "_ikh#")
mc.rename(eff, name + "_eff#")
# adjust "offset" joint position for proper ik spline twist
mc.move(positions[2][0], positions[2][1], positions[2][2],
ik[3] + ".scalePivot", ik[3] + ".rotatePivot")
mc.move(0,
-0.001,
0,
ik[3] + ".scalePivot",
ik[3] + ".rotatePivot",
r=True)
c1 = mc.cluster(crv + ".cv[0]")[1]
c2 = mc.cluster(crv + ".cv[1]", crv + ".cv[2]")[1]
c3 = mc.cluster(crv + ".cv[3]")[1]
mc.hide(c1, c2, c3)
mc.parent(c1, ctrl[0])
mc.parent(c2, ctrl[1])
mc.parent(c3, ctrl[2])
mc.connectAttr(ctrl[0] + ".worldMatrix", ikh + ".dWorldUpMatrix")
mc.connectAttr(ctrl[2] + ".worldMatrix", ikh + ".dWorldUpMatrixEnd")
mc.select(ik[5], ik[8])
ikh, eff, crv2 = mc.ikHandle(sol="ikSplineSolver")
crv2 = mc.parent(crv2, grp)[0]
mc.setAttr(crv2 + ".t", 0, 0, 0)
mc.setAttr(crv2 + ".r", 0, 0, 0)
mc.setAttr(crv2 + ".s", 1, 1, 1)
mc.setAttr(crv2 + ".it", False)
mc.setAttr(ikh + ".dTwistControlEnable", True)
mc.setAttr(ikh + ".dWorldUpType", 4)
mc.setAttr(ikh + ".dWorldUpAxis", 3)
mc.setAttr(ikh + ".dWorldUpVector", 0, 0, -1)
mc.setAttr(ikh + ".dWorldUpVectorEnd", 0, 0, -1)
ikh = mc.parent(ikh, grp)[0]
mc.hide(ikh, crv2)
ikh = mc.rename(ikh, name + "_ikh#")
mc.rename(eff, name + "_eff#")
# adjust "offset" joint position for proper ik spline twist
mc.move(positions[5][0], positions[5][1], positions[5][2],
ik[7] + ".scalePivot", ik[7] + ".rotatePivot")
mc.move(0,
-0.001,
0,
ik[7] + ".scalePivot",
ik[7] + ".rotatePivot",
r=True)
c1 = mc.cluster(crv2 + ".cv[0]")[1]
c2 = mc.cluster(crv2 + ".cv[1]", crv2 + ".cv[2]")[1]
c3 = mc.cluster(crv2 + ".cv[3]")[1]
mc.hide(c1, c2, c3)
mc.parent(c1, ik[4])
mc.parent(c2, ctrl[3])
mc.parent(c3, ctrl[4])
mc.connectAttr(ctrl[2] + ".worldMatrix", ikh + ".dWorldUpMatrix")
mc.connectAttr(ctrl[4] + ".worldMatrix", ikh + ".dWorldUpMatrixEnd")
mc.delete(mc.ls(typ="tweak"))
c = mc.orientConstraint(ctrl[0], ik[1], mo=True)[0]
mc.rename(c, ik[1] + "_oricon")
c = mc.orientConstraint(ctrl[4], ik[8], mo=True)[0]
mc.rename(c, ik[8] + "_oricon")
#
# stretch math
#
ci = mc.createNode("curveInfo")
mc.connectAttr(crv + ".worldSpace", ci + ".inputCurve")
ci2 = mc.createNode("curveInfo")
mc.connectAttr(crv2 + ".worldSpace", ci2 + ".inputCurve")
n = mc.listRelatives(crv, pa=True, s=True)[1]
tg = mc.createNode("transformGeometry")
mc.connectAttr(n + ".worldSpace", tg + ".inputGeometry")
mc.connectAttr(grp + ".worldMatrix", tg + ".transform")
ci3 = mc.createNode("curveInfo")
mc.connectAttr(tg + ".outputGeometry", ci3 + ".inputCurve")
n = mc.listRelatives(crv2, pa=True, s=True)[1]
tg = mc.createNode("transformGeometry")
mc.connectAttr(n + ".worldSpace", tg + ".inputGeometry")
mc.connectAttr(grp + ".worldMatrix", tg + ".transform")
ci4 = mc.createNode("curveInfo")
mc.connectAttr(tg + ".outputGeometry", ci4 + ".inputCurve")
md1 = mc.createNode("multiplyDivide")
mc.setAttr(md1 + ".operation", 2)
mc.connectAttr(ci + ".arcLength", md1 + ".input1X")
mc.connectAttr(ci3 + ".arcLength", md1 + ".input2X")
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(md1 + ".outputX", md2 + ".input1X")
mc.connectAttr(ctrl[2] + ".stretchBelow", md2 + ".input2X")
c = mc.createNode("condition")
mc.setAttr(c + ".secondTerm", 1)
mc.setAttr(c + ".operation", 3)
mc.connectAttr(md1 + ".outputX", c + ".colorIfTrueR")
mc.connectAttr(md2 + ".outputX", c + ".firstTerm")
mc.connectAttr(c + ".outColorR", ik[0] + ".sx")
mc.connectAttr(c + ".outColorR", ik[2] + ".sx")
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(md1 + ".outputX", md2 + ".input1X")
mc.connectAttr(ctrl[2] + ".stretchAbove", md2 + ".input2X")
c = mc.createNode("condition")
mc.setAttr(c + ".secondTerm", 1)
mc.setAttr(c + ".operation", 3)
mc.connectAttr(md1 + ".outputX", c + ".colorIfTrueR")
mc.connectAttr(md2 + ".outputX", c + ".firstTerm")
mc.connectAttr(c + ".outColorR", ik[4] + ".sx")
md1 = mc.createNode("multiplyDivide")
mc.setAttr(md1 + ".operation", 2)
mc.connectAttr(ci2 + ".arcLength", md1 + ".input1X")
mc.connectAttr(ci4 + ".arcLength", md1 + ".input2X")
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(md1 + ".outputX", md2 + ".input1X")
mc.connectAttr(ctrl[4] + ".stretch", md2 + ".input2X")
c = mc.createNode("condition")
mc.setAttr(c + ".secondTerm", 1)
mc.setAttr(c + ".operation", 3)
mc.connectAttr(md1 + ".outputX", c + ".colorIfTrueR")
mc.connectAttr(md2 + ".outputX", c + ".firstTerm")
mc.connectAttr(c + ".outColorR", ik[5] + ".sx")
mc.connectAttr(c + ".outColorR", ik[6] + ".sx")
j = 0
jnt = [None] * 6
for i in range(1, 9):
if i == 3 or i == 7: continue
jnt[j] = mc.createNode("joint", n=name + "_jnt" + str(j + 1), p=grp)
mc.setAttr(jnt[j] + ".radius", radius * 0.5)
mc.connectAttr(ctrl[0] + ".joints", jnt[j] + ".v")
c = mc.parentConstraint(ik[i], jnt[j])[0]
mc.rename(c, name + "_jnt" + str(j) + "_parcon")
j += 1
# selection sets
common.sets(name, jnt, None, ctrl)
# selectable joints
common.selectable(ctrl[0] + ".editJoints", jnt)
if tmp: mc.delete(tmp)
ik[0] = mc.parent(ik[0], grp)[0]
mc.hide(ik[0])
mc.select(grp)
mc.dgdirty(a=True)
return grp
def main(name="twist",
control=None,
parent=None,
stable=None,
_twist=None,
scale=None,
aim=(1, 0, 0),
up=(0, 1, 0),
wu=(0, 0, 0),
wuo=None,
count=4):
if not control:
control = common.control(name=name, color=13)[1]
addControlToSets = True
else:
addControlToSets = False
if not mc.objExists(control + ".joints"):
mc.addAttr(control, ln="joints", at="bool", dv=True, k=True)
if not mc.objExists(control + ".editJoints"):
mc.addAttr(control, ln="editJoints", at="bool", k=True)
if count < 1: count = 1
elif count > 4: count = 4
count += 1
tw = [None] * count
tw[0] = mc.duplicate(stable)[0]
try:
mc.delete(mc.listRelatives(tw[0], pa=True, c=True))
except:
pass
l = mc.listConnections(tw[0] + ".message", s=False, d=True, p=True) or []
for na in l:
mc.disconnectAttr(tw[0] + ".message", na)
for a in [
"t", "tx", "ty", "tz", "r", "rx", "ry", "rz", "s", "sx", "sy",
"sz", "v", "radius", "template"
]:
mc.setAttr(tw[0] + "." + a, l=False, k=True)
mc.setAttr(tw[0] + ".radius", mc.getAttr(tw[0] + ".radius"))
mc.setAttr(tw[0] + ".drawStyle", 0)
mc.setAttr(tw[0] + ".template", False)
tw[0] = mc.rename(tw[0], name + "_twr#")
try:
tw[0] = mc.parent(tw[0], parent)[0]
except:
pass
tw[1] = mc.duplicate(tw[0])[0]
mc.setAttr(tw[1] + ".drawStyle", 2)
for i in range(2, count):
tw[i] = mc.duplicate(tw[0])[0]
if not wuo:
c = mc.aimConstraint(_twist,
tw[0],
aim=aim,
u=up,
wut="vector",
wu=wu,
mo=True)[0]
else:
c = mc.aimConstraint(_twist,
tw[0],
aim=aim,
u=up,
wut="objectrotation",
wu=wu,
wuo=wuo,
mo=True)[0]
mc.rename(c, tw[0] + "_aimcon")
c = mc.aimConstraint(_twist,
tw[1],
aim=aim,
u=up,
wut="objectrotation",
wu=(0, 1, 0),
wuo=_twist,
mo=True)[0]
mc.rename(c, tw[0] + "_aimcon")
if count == 5:
wgt = [0.75, 0.5, 0.25]
elif count == 4:
wgt = [0.6666, 0.3333]
else: # count == 3
wgt = [0.5]
for i in range(2, count):
tw[i] = mc.rename(tw[i], name + "_tw#")
c = mc.pointConstraint(tw[0], _twist, tw[i])[0]
mc.setAttr(c + "." + tw[0].split("|")[-1] + "W0", wgt[i - 2])
mc.setAttr(c + "." + _twist.split("|")[-1] + "W1", 1 - wgt[i - 2])
mc.delete(c)
c = mc.orientConstraint(tw[0], tw[1], tw[i])[0]
mc.setAttr(c + "." + tw[0].split("|")[-1] + "W0", wgt[i - 2])
mc.setAttr(c + "." + tw[1].split("|")[-1] + "W1", 1 - wgt[i - 2])
mc.setAttr(c + ".interpType", 2)
mc.rename(c, tw[i] + "_oricon")
if count > 2: mc.parent(tw[2:], tw[1])
mc.select(tw[0], tw[1])
mc.connectAttr(scale + ".s", tw[1] + ".s")
mc.connectAttr(control + ".joints", tw[0] + ".v")
mc.connectAttr(control + ".joints", tw[1] + ".v")
tw.pop(1)
# selection sets
if addControlToSets: common.sets(name, tw, [control], None)
else: common.sets(name, tw, None, None)
# selectable joints
common.selectable(control + ".editJoints", tw)
mc.select(control)
mc.dgdirty(a=True)
return control
def main(name="leg",
positions=None,
inheritTemplateRotations=False,
footWidth=1,
radius=1,
ikShape="cube"):
# create template joints if needed
tmp = None
if not positions:
positions = template(name=name)
tmp = positions[:] # copy
# positions/orientations from template transforms/joints
rotations = [None] * 6
for i in range(6):
if type(positions[i]) == str or type(positions[i]) == unicode:
if inheritTemplateRotations:
rotations[i] = mc.xform(positions[i], q=True, ro=True, ws=True)
positions[i] = mc.xform(positions[i], q=True, rp=True, ws=True)
grp = mc.createNode("transform", n=name)
#
# ik joints
#
ik = [None] * 5
for i in range(5):
ik[i] = mc.createNode("joint", n=name + "_ik" + str(i + 1))
mc.setAttr(ik[i] + ".t", positions[i][0], positions[i][1],
positions[i][2])
if inheritTemplateRotations:
mc.setAttr(ik[i] + ".r", rotations[i][0], rotations[i][1],
rotations[i][2])
if not inheritTemplateRotations:
if positions[0][0] >= -0.001:
mc.delete(
mc.aimConstraint(ik[1],
ik[0],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[2]))
mc.delete(
mc.aimConstraint(ik[2],
ik[1],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[0]))
mc.delete(
mc.aimConstraint(ik[1],
ik[2],
aim=(-1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[0]))
mc.delete(
mc.aimConstraint(ik[4],
ik[3],
aim=(1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[1]))
mc.delete(
mc.aimConstraint(ik[3],
ik[4],
aim=(-1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[1]))
else:
mc.delete(
mc.aimConstraint(ik[1],
ik[0],
aim=(-1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[2]))
mc.delete(
mc.aimConstraint(ik[2],
ik[1],
aim=(-1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[0]))
mc.delete(
mc.aimConstraint(ik[1],
ik[2],
aim=(1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=ik[0]))
mc.delete(
mc.aimConstraint(ik[4],
ik[3],
aim=(-1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[1]))
mc.delete(
mc.aimConstraint(ik[3],
ik[4],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=ik[1]))
for i in range(5):
r = mc.getAttr(ik[i] + ".r")[0]
mc.setAttr(ik[i] + ".jo", r[0], r[1], r[2])
mc.setAttr(ik[i] + ".r", 0, 0, 0)
mc.setAttr(ik[i] + ".radius", radius * 0.5)
#
# ik controls
#
ik_ctrl_grp = [None] * 2
ik_ctrl = [None] * 2
ik_ctrl_grp[0], ik_ctrl[0] = common.control(
name=name + "_ik1",
parent=grp,
position=ik[2],
color=6,
radius=radius,
shape=ikShape,
lockAttr=["s", "v"],
hideAttr=["sx", "sy", "sz", "v"])
mc.addAttr(ik_ctrl[0], ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[0], ln="editJoints", at="bool", k=True)
mc.addAttr(ik_ctrl[0], ln="fkControls", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[0], ln="ikControls", at="bool", dv=True, k=True)
mc.addAttr(ik_ctrl[0], ln="stretch", at="bool", k=True)
mc.addAttr(ik_ctrl[0], ln="footRoll", at="double", k=True)
mc.addAttr(ik_ctrl[0], ln="footSide", at="double", k=True)
mc.addAttr(ik_ctrl[0], ln="heelTwist", at="double", k=True)
mc.addAttr(ik_ctrl[0], ln="ballLift", at="double", k=True)
mc.addAttr(ik_ctrl[0], ln="toeLift", at="double", k=True)
mc.addAttr(ik_ctrl[0], ln="toeTwist", at="double", k=True)
heel = mc.createNode("transform", n=name + "_heel_grp")
mc.setAttr(heel + ".t", positions[5][0], positions[5][1], positions[5][2])
heel = mc.parent(heel, ik_ctrl[0])[0]
mc.setAttr(heel + ".r", 0, 0, 0)
mc.connectAttr(ik_ctrl[0] + ".footRoll", heel + ".rx")
mc.connectAttr(ik_ctrl[0] + ".heelTwist", heel + ".ry")
mc.transformLimits(heel, rx=(0, 0), erx=(False, True))
mc.hide(heel)
side_rt = mc.createNode("transform", n=name + "_side_rt_grp", p=heel)
mc.setAttr(side_rt + ".r", 0, 0, 0)
mc.delete(mc.pointConstraint(ik[3], side_rt))
mc.setAttr(side_rt + ".tx", -footWidth)
mc.connectAttr(ik_ctrl[0] + ".footSide", side_rt + ".rz")
mc.transformLimits(side_rt, rz=(0, 0), erz=(True, False))
side_lf = mc.createNode("transform", n=name + "_side_lf_grp", p=side_rt)
mc.delete(mc.pointConstraint(ik[3], side_lf))
mc.setAttr(side_lf + ".r", 0, 0, 0)
mc.setAttr(side_lf + ".tx", footWidth * 2)
mc.connectAttr(ik_ctrl[0] + ".footSide", side_lf + ".rz")
mc.transformLimits(side_lf, rz=(0, 0), erz=(False, True))
toe = mc.createNode("transform", n=name + "_toe_grp", p=side_lf)
mc.delete(mc.pointConstraint(ik[4], toe))
mc.setAttr(toe + ".r", 0, 0, 0)
mc.connectAttr(ik_ctrl[0] + ".toeTwist", toe + ".ry")
mc.setDrivenKeyframe(toe + ".rx",
v=0,
dv=45,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(toe + ".rx",
v=45,
dv=90,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
ball = mc.createNode("transform", n=name + "_ball_grp", p=toe)
mc.delete(mc.pointConstraint(ik[3], ball))
mc.setAttr(ball + ".r", 0, 0, 0)
# mc.connectAttr(ik_ctrl[0]+".ballLift", ball+".rax")
mc.setDrivenKeyframe(ball + ".rx",
v=0,
dv=0,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(ball + ".rx",
v=45,
dv=45,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
ik_ctrl_grp[1], ik_ctrl[1] = common.control(
name=name + "_pv",
parent=grp,
position=ik[1],
rotation=ik[1],
normal=(0, 0, 1),
color=6,
radius=radius * 0.25,
shape=ikShape,
lockAttr=["r", "s"],
hideAttr=["rx", "ry", "rz", "sx", "sy", "sz", "v"])
if positions[0][0] <= -0.001:
direction = 1 if inheritTemplateRotations else -1
mc.move(0,
0,
direction * 3 * radius,
ik_ctrl_grp[1],
os=True,
r=True,
wd=True)
else:
mc.move(0, 0, 3 * radius, ik_ctrl_grp[1], os=True, r=True, wd=True)
mc.setAttr(ik_ctrl_grp[1] + ".r", 0, 0, 0)
mc.connectAttr(ik_ctrl[0] + ".ikControls", ik_ctrl_grp[1] + ".v")
#
# ik stretch joints
#
ik2 = [None] * 3
for i in range(3):
ik2[i] = mc.duplicate(ik[i])[0]
ik2[i] = mc.rename(ik2[i], name + "_ik" + str(i + 1) + "_str")
if i == 0: ik2[i] = mc.parent(ik2[i], grp)[0]
else: ik2[i] = mc.parent(ik2[i], ik2[i - 1])[0]
c = mc.parentConstraint(ik[i], ik2[i])[0]
mc.rename(c, name + "_ik" + str(i + 1) + "_parcon")
mc.setAttr(ik2[i] + ".jo", 0, 0, 0)
#
# fk joints and controls
#
fk_ctrl = [None] * 4
jnt = [None] * 4
for i in range(4):
# fk controls
fk_ctrl[i] = mc.duplicate(ik[i])[0]
fk_ctrl[i] = mc.rename(fk_ctrl[i], name + "_fk" + str(i + 1) + "_ctrl")
if i != 3:
mc.connectAttr(ik2[i] + ".t", fk_ctrl[i] + ".t")
mc.connectAttr(ik2[i] + ".r", fk_ctrl[i] + ".jo")
else:
mc.connectAttr(ik[i] + ".t", fk_ctrl[i] + ".t")
mc.connectAttr(ik[i] + ".jo", fk_ctrl[i] + ".jo")
mc.setAttr(fk_ctrl[i] + ".r", 0, 0, 0)
common.control(addShapeTo=fk_ctrl[i],
normal=(1, 0, 0),
color=13,
radius=radius * 0.7)
mc.connectAttr(ik_ctrl[0] + ".fkControls",
mc.listRelatives(fk_ctrl[i], pa=True, s=True)[0] + ".v")
if i: fk_ctrl[i] = mc.parent(fk_ctrl[i], fk_ctrl[i - 1])[0]
else: fk_ctrl[i] = mc.parent(fk_ctrl[i], grp)[0]
mc.setAttr(fk_ctrl[i] + ".drawStyle", 2)
# fk joints
jnt[i] = mc.duplicate(ik[i])[0]
jnt[i] = mc.parent(jnt[i], fk_ctrl[i])[0]
jnt[i] = mc.rename(jnt[i], name + "_jnt" + str(i + 1))
for a in ["t", "r", "jo"]:
mc.setAttr(jnt[i] + "." + a, 0, 0, 0)
mc.connectAttr(ik_ctrl[0] + ".joints", jnt[i] + ".v")
mc.setAttr(fk_ctrl[i] + ".drawStyle", 2)
rev = mc.createNode("reverse")
mc.connectAttr(ik_ctrl[0] + ".toeLift", rev + ".inputX")
mc.connectAttr(rev + ".outputX", jnt[3] + ".ry")
mc.setDrivenKeyframe(fk_ctrl[3] + ".ray",
v=30,
dv=-30,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(fk_ctrl[3] + ".ray",
v=0,
dv=0,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
mc.setDrivenKeyframe(fk_ctrl[3] + ".ray",
v=-45,
dv=45,
cd=ik_ctrl[0] + ".footRoll",
itt="linear",
ott="linear")
#
# ik handles
#
for i in range(1, 5):
ik[i] = mc.parent(ik[i], ik[i - 1])[0]
mc.select(ik)
mc.SetPreferredAngle()
common.ikHandle(name + "_ball", ik[2], ik[3], parent=ball)
common.ikHandle(name + "_toe", ik[3], ik[4], parent=toe)
ikh = common.ikHandle(name, ik[0], ik[2], parent=ball)[0]
pvc = mc.poleVectorConstraint(ik_ctrl[1], ikh)[0]
mc.rename(pvc, name + "_pvcon")
#
# stretch math
#
ik1_jnt_grp = mc.createNode("transform", n=ik[0] + "_grp", p=grp)
mc.delete(mc.pointConstraint(ik[0], ik1_jnt_grp))
n = mc.duplicate(ik1_jnt_grp)[0]
n = mc.rename(n, "str_grp")
db1 = mc.createNode("distanceBetween")
mc.connectAttr(ik1_jnt_grp + ".worldMatrix", db1 + ".inMatrix1")
mc.connectAttr(ik_ctrl[0] + ".worldMatrix", db1 + ".inMatrix2")
db2 = mc.createNode("distanceBetween")
mc.connectAttr(n + ".worldMatrix", db2 + ".inMatrix1")
mc.connectAttr(ik_ctrl_grp[0] + ".worldMatrix", db2 + ".inMatrix2")
md1 = mc.createNode("multiplyDivide")
mc.setAttr(md1 + ".operation", 2)
mc.connectAttr(db1 + ".distance", md1 + ".input1X")
mc.connectAttr(db2 + ".distance", md1 + ".input2X")
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(md1 + ".outputX", md2 + ".input1X")
mc.connectAttr(ik_ctrl[0] + ".stretch", md2 + ".input2X")
c = mc.createNode("condition")
mc.setAttr(c + ".secondTerm", 1)
mc.setAttr(c + ".operation", 3)
mc.connectAttr(md1 + ".outputX", c + ".colorIfTrueR")
mc.connectAttr(md2 + ".outputX", c + ".firstTerm")
mc.connectAttr(c + ".outColorR", ik[0] + ".sx")
mc.connectAttr(c + ".outColorR", ik[1] + ".sx")
# offset the stretch group to enable full extension
# of the leg before it starts stretching
db3 = mc.createNode("distanceBetween")
mc.connectAttr(ik[0] + ".worldMatrix", db3 + ".inMatrix1")
mc.connectAttr(ik[1] + ".worldMatrix", db3 + ".inMatrix2")
d = mc.getAttr(db3 + ".distance")
mc.connectAttr(ik[2] + ".worldMatrix", db3 + ".inMatrix1", f=True)
d += mc.getAttr(db3 + ".distance") - mc.getAttr(db1 + ".distance")
mc.delete(db3)
p = mc.xform(ik[0], q=True, rp=True, ws=True)
p2 = mc.xform(ik[2], q=True, rp=True, ws=True)
p[0] -= p2[0]
p[1] -= p2[1]
p[2] -= p2[2]
m = math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2])
p[0] /= m
p[1] /= m
p[2] /= m
p2 = mc.getAttr(n + ".t")[0]
mc.setAttr(n + ".t", p2[0] + p[0] * d, p2[1] + p[1] * d, p2[2] + p[2] * d)
#
# lock and hide attributes
#
for i in range(4):
if i == 0 or i == 2:
for a in ["tx", "ty", "tz", "sx", "sy", "sz", "v", "radius"]:
mc.setAttr(fk_ctrl[i] + "." + a, l=True, k=False, cb=False)
else:
for a in [
"tx", "ty", "tz", "rx", "rz", "sx", "sy", "sz", "v",
"radius"
]:
mc.setAttr(fk_ctrl[i] + "." + a, l=True, k=False, cb=False)
# selection sets
common.sets(name, jnt, fk_ctrl, ik_ctrl)
# selectable joints
common.selectable(ik_ctrl[0] + ".editJoints", jnt)
# fk to ik bake ready
for i in range(3):
mc.addAttr(ik_ctrl[0], ln="fk" + str(i + 1), at="message", h=True)
mc.addAttr(fk_ctrl[i], ln="fk", at="message", h=True)
mc.connectAttr(ik_ctrl[0] + ".fk" + str(i + 1), fk_ctrl[i] + ".fk")
mc.addAttr(ik_ctrl[0], ln="ik1", at="message", h=True)
mc.addAttr(ik_ctrl[1], ln="ik", at="message", h=True)
mc.connectAttr(ik_ctrl[0] + ".ik1", ik_ctrl[1] + ".ik")
# organize
if tmp: mc.delete(tmp)
mc.hide(ik[0], ik2[0])
mc.parent(ik[0], ik1_jnt_grp)
mc.select(grp)
mc.dgdirty(a=True)
return grp
def main(wheels=None, parent=None, radius=1):
if wheels == None: wheels = mc.ls(sl=True, o=True) or []
if len(wheels) < 2: return
grp = mc.createNode("transform", n="chassis", ss=True)
bb = mc.exactWorldBoundingBox(wheels)
tx = (bb[3] + bb[0]) * 0.5
ty = (bb[4] + bb[1]) * 0.5
tz = (bb[5] + bb[2]) * 0.5
sx = (bb[3] - bb[0]) * 2 * radius
sz = (bb[5] - bb[2]) * 2 * radius
grp2, ctrl = common.control(name="chassis",
position=[tx, ty, tz],
radius=[sx, sz],
shape="square",
parent=grp,
lockAttr="v",
hideAttr="v")
mc.addAttr(ctrl, ln="joints", at="bool", dv=True, k=True)
mc.addAttr(ctrl, ln="editJoints", at="bool", k=True)
mc.addAttr(ctrl, ln="controls", at="bool", dv=True, k=True)
mc.addAttr(ctrl, ln="placers", at="bool", k=True)
mc.addAttr(ctrl, ln="wheels", at="bool", dv=True, k=True)
mc.addAttr(ctrl, ln="terrain", at="bool", dv=True, k=True)
mc.addAttr(ctrl, ln="editTerrain", at="bool", k=True)
mc.addAttr(ctrl, ln="terrainDetection", at="bool", dv=True, k=True)
jnt = mc.createNode("joint", n="chassis_jnt", p=ctrl, ss=True)
mc.setAttr(jnt + ".radius", radius * 0.5)
mc.connectAttr(ctrl + ".joints", jnt + ".v")
common.selectable(ctrl + ".editJoints", jnt)
common.sets("chassis", jnt, None, None)
fr_wheels = []
bk_wheels = []
lf_wheels = []
rt_wheels = []
for n in wheels:
name = n.replace("_grp", "")
mc.connectAttr(ctrl + ".joints", name + "_ctrl.joints")
mc.setAttr(name + "_ctrl.joints", k=False)
mc.connectAttr(ctrl + ".editJoints", name + "_ctrl.editJoints")
mc.setAttr(name + "_ctrl.editJoints", k=False)
mc.connectAttr(ctrl + ".controls", name + "_ctrl.v")
mc.setAttr(name + "_ctrl.v", k=False)
mc.connectAttr(ctrl + ".controls",
name + "_placer_ctrlShape.overrideVisibility")
mc.connectAttr(ctrl + ".placers", name + "_ctrl.placer")
mc.setAttr(name + "_ctrl.placer", k=False)
mc.connectAttr(ctrl + ".wheels", name + "_ctrl.wheel")
mc.setAttr(name + "_ctrl.wheel", k=False)
mc.connectAttr(ctrl + ".terrain", name + "_ctrl.terrain")
mc.setAttr(name + "_ctrl.terrain", k=False)
mc.connectAttr(ctrl + ".editTerrain", name + "_ctrl.editTerrain")
mc.setAttr(name + "_ctrl.editTerrain", k=False)
mc.connectAttr(ctrl + ".terrainDetection",
name + "_ctrl.terrainDetection")
mc.setAttr(name + "_ctrl.terrainDetection", k=False)
p = mc.xform(n, q=True, ws=True, rp=True)
if p[0] >= 0: lf_wheels.append(n)
else: rt_wheels.append(n)
if p[2] >= 0: fr_wheels.append(n)
else: bk_wheels.append(n)
bb = mc.exactWorldBoundingBox(fr_wheels)
tx = (bb[3] + bb[0]) * 0.5
ty = bb[4] * 1.25
tz = (bb[5] + bb[2]) * 0.5
r = (bb[3] + bb[0]) * 0.25
if r < (bb[4] + bb[1]) * 0.25: r = (bb[4] + bb[1]) * 0.25
if r < (bb[5] + bb[2]) * 0.25: r = (bb[5] + bb[2]) * 0.25
grp3, ctrl2 = common.control(
name="steering",
position=[tx, ty, tz],
radius=radius * r,
parent=grp,
lockAttr=["tx", "ty", "tz", "rx", "rz", "sx", "sy", "sz"],
hideAttr=["tx", "ty", "tz", "rx", "rz", "sx", "sy", "sz", "v"])
mc.connectAttr(ctrl + ".controls", ctrl2 + ".v")
mc.transformLimits(ctrl2, ry=(-55, 55), ery=(1, 1))
fr_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_fr_pos_grp",
ss=True)
bk_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_bk_pos_grp",
ss=True)
lf_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_lf_pos_grp",
ss=True)
rt_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_rt_pos_grp",
ss=True)
fr_lf_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_fr_lf_aim_grp",
ss=True)
bk_lf_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_bk_lf_aim_grp",
ss=True)
bk_rt_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_bk_rt_aim_grp",
ss=True)
fr_rt_pos_grp = mc.createNode("transform",
p=grp,
n=name + "_fr_rt_aim_grp",
ss=True)
for n in wheels:
wheel_ctrl = n.replace("_grp", "_ctrl")
if n in fr_wheels:
mc.connectAttr(ctrl2 + ".ry", wheel_ctrl + ".ry")
mc.setAttr(wheel_ctrl + ".ry", k=False, l=True)
else:
mc.setAttr(wheel_ctrl + ".tilt", 0)
mc.pointConstraint(wheel_ctrl, grp2, skip=("x"))
if n in lf_wheels: mc.pointConstraint(wheel_ctrl, lf_pos_grp)
elif n in rt_wheels: mc.pointConstraint(wheel_ctrl, rt_pos_grp)
if n in fr_wheels:
mc.pointConstraint(wheel_ctrl, fr_pos_grp, skip=("x"))
elif n in bk_wheels:
mc.pointConstraint(wheel_ctrl, bk_pos_grp)
mc.setAttr(wheel_ctrl + ".ry", k=False, l=True)
mc.connectAttr(grp2 + ".rz", wheel_ctrl + ".rz")
mc.setAttr(wheel_ctrl + ".rz", k=False, l=True)
mc.pointConstraint(fr_pos_grp, bk_pos_grp, lf_pos_grp, rt_pos_grp,
fr_lf_pos_grp)
mc.pointConstraint(fr_pos_grp, bk_pos_grp, lf_pos_grp, rt_pos_grp,
bk_lf_pos_grp)
mc.pointConstraint(fr_pos_grp, bk_pos_grp, lf_pos_grp, rt_pos_grp,
bk_rt_pos_grp)
mc.pointConstraint(fr_pos_grp, bk_pos_grp, lf_pos_grp, rt_pos_grp,
fr_rt_pos_grp)
mc.aimConstraint(fr_pos_grp,
fr_lf_pos_grp,
aim=[0, 0, 1],
u=[1, 0, 0],
wut="object",
wuo=lf_pos_grp)
mc.aimConstraint(lf_pos_grp,
bk_lf_pos_grp,
aim=[1, 0, 0],
u=[0, 0, -1],
wut="object",
wuo=bk_pos_grp)
mc.aimConstraint(bk_pos_grp,
bk_rt_pos_grp,
aim=[0, 0, -1],
u=[-1, 0, 0],
wut="object",
wuo=rt_pos_grp)
mc.aimConstraint(rt_pos_grp,
fr_rt_pos_grp,
aim=[-1, 0, 0],
u=[1, 0, 0],
wut="object",
wuo=fr_pos_grp)
mc.orientConstraint(fr_lf_pos_grp,
bk_lf_pos_grp,
bk_rt_pos_grp,
fr_rt_pos_grp,
grp2,
mo=True)
common.sets("chassis", None, [ctrl, ctrl2], None)
mc.select(grp)
mc.dgdirty(a=True)
return grp, ctrl
def main(name="assembly", position=(0,0,0), radius=1, fbx=False,
cog=True, body=True, pelvis=True):
if type(position) == str or type(position) == unicode:
position = mc.xform(position, q=True, rp=True, ws=True)
grp = mc.createNode("transform", n=name)
mc.addAttr(grp, ln="joints", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editJoints", at="bool", k=True)
if fbx:
mc.setAttr(grp+".joints", False)
mc.addAttr(grp, ln="fbxJoints", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editFbxJoints", at="bool", k=True)
mc.addAttr(grp, ln="controls", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="_geometry", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editGeometry", at="bool", k=True)
#
# controls
#
ctrl = []
ctrl.append(common.control(name="world", parent=grp, radius=radius*5, color=13,
lockAttr=["v"], hideAttr=["v"])[1])
if cog:
ctrl.append(common.control(name="cog", parent=ctrl[0], position=position,
color=13, radius=radius*4, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
if body:
ctrl.append(common.control(name="body", parent=ctrl[1], position=ctrl[1],
color=13, radius=radius*3, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
if pelvis:
ctrl.append(common.control(name="pelvis", parent=ctrl[2], position=ctrl[2],
radius=radius*2, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
grps = [None]*2
rev = mc.createNode("reverse")
if fbx:
grps[0] = mc.createNode("transform", n="skeleton_fbx")
grps[1] = mc.createNode("transform", n="geometry_fbx")
mc.connectAttr(grp+".fbxJoints", grps[0]+".v")
mc.setAttr(grps[0]+".overrideDisplayType", 2)
mc.connectAttr(grp+".editFbxJoints", rev+".inputX")
mc.connectAttr(rev+".outputX", grps[0]+".overrideEnabled")
mc.createNode("transform", n="constraints_fbx", p=grp)
else:
grps[1] = mc.createNode("transform", n="geometry", p=grp)
mc.connectAttr(grp+"._geometry", grps[1]+".v")
mc.connectAttr(grp+".editGeometry", rev+".inputY")
mc.connectAttr(rev+".outputY", grps[1]+".overrideEnabled")
mc.setAttr(grps[1]+".overrideDisplayType", 2)
for n in grps:
for a in ["tx","ty","tz","rx","ry","rz","sx","sy","sz","v"]:
try: mc.setAttr(n+"."+a, l=True, k=False, cb=False)
except: pass
#
# selection sets
#
n1 = mc.sets(n="ik_controls_set", em=True)
n2 = mc.sets(n="fk_controls_set", em=True)
for n in ctrl: mc.connectAttr(n+".message", n2+".dnSetMembers", na=True)
n3 = mc.sets(n="joints_set", em=True)
n4 = mc.sets(n=name+"_set", em=True)
mc.sets(n1, n2, n3, add=n4)
mc.select(grp)
mc.dgdirty(a=True)
return grp
def main(name="hand",
side="",
control=None,
parent=None,
positions=None,
inheritTemplateRotations=False,
radius=1):
# create template joints if needed
tmp = None
if not positions:
positions = template(name=name)
tmp = copy.deepcopy(positions)
cnt = len(positions)
if cnt == 0: return
# positions from template transforms/joints
rotations = {}
for i in range(cnt):
cnt2 = len(positions[i])
if cnt2 < 3:
raise Exception("At least 3 joints are needed to form a finger.")
for j in range(cnt2):
if type(positions[i][j]) == str or type(
positions[i][j]) == unicode:
if inheritTemplateRotations:
if i not in rotations.viewkeys():
rotations[i] = [None] * cnt2
rotations[i][j] = mc.xform(positions[i][j],
q=True,
ro=True,
ws=True)
positions[i][j] = mc.xform(positions[i][j],
q=True,
rp=True,
ws=True)
if not control:
center = [0, 0, 0]
for i in range(cnt):
center[0] += positions[i][0][0]
center[1] += positions[i][0][1]
center[2] += positions[i][0][2]
center[0] /= cnt
center[1] /= cnt
center[2] /= cnt
control = common.control(name=name,
position=center,
normal=(1, 0, 0),
color=17,
radius=radius * 2,
lockAttr=("v"),
hideAttr=("v"))[1]
parent = control
if not mc.objExists(control + ".joints"):
mc.addAttr(control, ln="joints", at="bool", dv=True, k=True)
if not mc.objExists(control + ".editJoints"):
mc.addAttr(control, ln="editJoints", at="bool", dv=True, k=True)
if not mc.objExists(control + ".fingerControls"):
mc.addAttr(control, ln="fingerControls", at="bool", dv=True, k=True)
if not mc.objExists(control + ".bend"):
mc.addAttr(control, ln="bend", at="double", min=-10, max=10, k=True)
if not mc.objExists(control + ".splay"):
mc.addAttr(control, ln="splay", at="double", min=-10, max=10, k=True)
md1 = mc.createNode("multiplyDivide")
mc.connectAttr(control + ".bend", md1 + ".input1.input1X")
mc.connectAttr(control + ".bend", md1 + ".input1.input1Y")
mc.connectAttr(control + ".bend", md1 + ".input1.input1Z")
mc.setAttr(md1 + ".input2X", 6)
mc.setAttr(md1 + ".input2Y", 9)
mc.setAttr(md1 + ".input2Z", 9)
md2 = mc.createNode("multiplyDivide")
mc.connectAttr(control + ".bend", md2 + ".input1.input1X")
mc.connectAttr(control + ".bend", md2 + ".input1.input1Y")
mc.connectAttr(control + ".bend", md2 + ".input1.input1Z")
mc.setAttr(md2 + ".input2X", 8)
mc.setAttr(md2 + ".input2Y", 11)
mc.setAttr(md2 + ".input2Z", 7.5)
jnt = [None] * cnt
ctrl_grp = [None] * cnt
ctrl = [None] * cnt
for i in range(cnt):
mc.select(cl=True)
cnt2 = len(positions[i])
jnt[i] = [None] * cnt2
if cnt2 == 3: j = 0
else: j = 1
jnt[i][0] = mc.createNode("joint",
n="finger_" + side + str(i + 1) + "_jnt" +
str(j + 1))
mc.setAttr(jnt[i][0] + ".t", positions[i][j][0], positions[i][j][1],
positions[i][j][2])
jnt[i][1] = mc.createNode("joint",
n="finger_" + side + str(i + 1) + "_jnt" +
str(j + 2))
mc.setAttr(jnt[i][1] + ".t", positions[i][j + 1][0],
positions[i][j + 1][1], positions[i][j + 1][2])
jnt[i][2] = mc.createNode("joint",
n="finger_" + side + str(i + 1) + "_jnt" +
str(j + 3))
mc.setAttr(jnt[i][2] + ".t", positions[i][j + 2][0],
positions[i][j + 2][1], positions[i][j + 2][2])
if j:
jnt[i][3] = mc.createNode("joint",
n="finger_" + side + str(i + 1) +
"_jnt1")
mc.setAttr(jnt[i][3] + ".t", positions[i][0][0],
positions[i][0][1], positions[i][0][2])
c = mc.aimConstraint(jnt[i][0],
jnt[i][3],
aim=(1, 0, 0),
u=(0, 0, 1),
wut="objectrotation",
wuo=parent)[0]
mc.rename(c, jnt[i][3] + "_aimcon")
jnt[i][3] = mc.parent(jnt[i][3], parent)[0]
mc.setAttr(jnt[i][3] + ".radius", radius * 0.3)
mc.connectAttr(control + ".joints", jnt[i][3] + ".v")
if not inheritTemplateRotations:
n = mc.createNode("transform")
mc.delete(mc.pointConstraint(jnt[i][0], jnt[i][2], n))
mc.delete(
mc.aimConstraint(jnt[i][2],
n,
aim=(1, 0, 0),
u=(0, 0, 1),
wut="object",
wuo=jnt[i][1]))
mc.delete(
mc.aimConstraint(jnt[i][1],
jnt[i][0],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=n))
mc.delete(
mc.aimConstraint(jnt[i][2],
jnt[i][1],
aim=(1, 0, 0),
u=(0, 0, -1),
wut="object",
wuo=n))
mc.delete(mc.orientConstraint(jnt[i][1], jnt[i][2]))
mc.delete(n)
else:
for j in range(cnt2):
mc.setAttr(jnt[i][j] + ".r", rotations[i][j][0],
rotations[i][j][1], rotations[i][j][2])
r = mc.getAttr(jnt[i][0] + ".r")[0]
mc.setAttr(jnt[i][0] + ".jo", r[0], r[1], r[2])
mc.setAttr(jnt[i][0] + ".r", 0, 0, 0)
r = mc.getAttr(jnt[i][1] + ".r")[0]
mc.setAttr(jnt[i][1] + ".jo", r[0], r[1], r[2])
mc.setAttr(jnt[i][1] + ".r", 0, 0, 0)
mc.parent(jnt[i][1], jnt[i][0])
r = mc.getAttr(jnt[i][2] + ".r")[0]
mc.setAttr(jnt[i][2] + ".jo", r[0], r[1], r[2])
mc.setAttr(jnt[i][2] + ".r", 0, 0, 0)
mc.parent(jnt[i][2], jnt[i][1])
ctrl_grp[i] = [None, None, None]
ctrl[i] = [None, None, None]
for j in range(3):
if j:
_parent = ctrl[i][j - 1]
lockAttr = ("t", "rx", "rz", "s", "v")
hideAttr = ("tx", "ty", "tz", "rx", "rz", "sx", "sy", "sz",
"v")
else:
_parent = parent
lockAttr = ("s", "v")
hideAttr = ("sx", "sy", "sz", "v")
ctrl_grp[i][j], ctrl[i][j] = common.control(
name="finger_" + side + str(i + 1) + "_fk" + str(j + 1),
parent=_parent,
position=jnt[i][j],
rotation=jnt[i][j],
normal=(1, 0, 0),
color=13,
radius=radius * 0.3,
lockAttr=lockAttr,
hideAttr=hideAttr,
numOffsetGroups=True)
mc.connectAttr(
control + ".fingerControls",
mc.listRelatives(ctrl[i][j], pa=True, s=True)[0] + ".v")
jnt[i][j] = mc.parent(jnt[i][j], ctrl[i][j])[0]
mc.setAttr(jnt[i][j] + ".radius", radius * 0.3)
mc.connectAttr(control + ".joints", jnt[i][j] + ".v")
# bend
mc.connectAttr(md2 + ".outputX", ctrl_grp[i][0] + ".ray")
mc.connectAttr(md2 + ".outputY", ctrl_grp[i][1] + ".ray")
mc.connectAttr(md2 + ".outputZ", ctrl_grp[i][2] + ".ray")
# splay
delta = 3.0 / (cnt * 0.5)
for i in range(cnt):
md = mc.createNode("multiplyDivide")
mc.connectAttr(control + ".splay", md + ".input1.input1X")
if mc.xform(ctrl_grp[i][0], q=True, rp=True, ws=True)[0] >= -0.001:
mc.setAttr(md + ".input2X", -3 + delta * i)
else:
mc.setAttr(md + ".input2X", 3 - delta * i)
if len(jnt[i]) == 4:
mc.connectAttr(md + ".outputX", ctrl_grp[i][0] + ".raz")
else:
mc.connectAttr(
md + ".outputX",
mc.listRelatives(ctrl[i][0], pa=True, p=True)[0] + ".raz")
# selection sets
if side: name += "_" + side
common.sets(name, sum(jnt, []), sum(ctrl, []), None)
# selectable joints
common.selectable(control + ".editJoints", sum(jnt, []))
if tmp: mc.delete(sum(tmp, []))
mc.select(control)
mc.dgdirty(a=True)
return control