def mmInsertJoint( *args ):
def normalize(vector_value):
length = math.sqrt(vector_value[0]**2 + vector_value[1]**2 + vector_value[2]**2)
x = vector_value[0]/length
y = vector_value[1]/length
z = vector_value[2]/length
result = [x, y, z]
return result
num_joints =input(10)
num_joints = num_joints+1
joint_list = cmds.ls(sl=True)
for r in joint_list:
first_joint_trans = cmds.xform(r, q=True, ws=True, t=True)
first_joint_ori = cmds.xform(r, q=True, ws=True, ro=True)
end_joint = cmds.listRelatives(r, f=True, c=True)
end_joint_rename=cmds.rename(end_joint[0], "end_to_delete______yeah")
end_joint_trans = cmds.xform(end_joint_rename, q=True, ws=True, t=True)
end_joint_ori = cmds.xform(end_joint_rename, q=True, ws=True, ro=True)
between_vector = [-(first_joint_trans[0]-end_joint_trans[0]),-(first_joint_trans[1]-end_joint_trans[1]),-(first_joint_trans[2]-end_joint_trans[2])]
vector_length = mel.eval(("mag(<<"+str(between_vector[0])+","+str(between_vector[1])+","+str(between_vector[2])+">>)"))
vector_normalize = normalize(between_vector)
for i in range(num_joints):
vector_to_add = [(vector_normalize[0]*((vector_length/num_joints)*((num_joints-float(i))))),(vector_normalize[1]*((vector_length/num_joints)*((num_joints-float(i))))),(vector_normalize[2]*((vector_length/num_joints)*((num_joints-float(i)))))]
inset_joint = cmds.insertJoint(r)
cmds.joint(inset_joint, e=True, co=True, o=(0,0,0), p=((first_joint_trans[0]+vector_to_add[0]), (first_joint_trans[1]+vector_to_add[1]), (first_joint_trans[2]+vector_to_add[2])))
cmds.delete(end_joint_rename)
def create_Joints():
src_joint = cmds.ls(sl=True)
cmds.select(hi=True)
findselAmt = cmds.ls(sl=True)
if (len(findselAmt)<2):
cmds.warning("select atleast 2 joints")
else:
noOfjoints = cmds.textField("Number",query=True,text=True)
num_jnts = float(noOfjoints)
cmds.pickWalk(d="down")
childjnt = cmds.ls(sl=True)
cmds.select(childjnt)
pos_child = cmds.xform(childjnt[0],query=True,translation=True,ws=True)
pos_start = cmds.xform(src_joint[0],query=True,translation=True,ws=True)
splitPos_x = pos_child[0] - pos_start[0]
splitPos_y = pos_child[1] - pos_start[1]
splitPos_z = pos_child[2] - pos_start[2]
splitPos = [(splitPos_x/num_jnts),(splitPos_y/num_jnts),(splitPos_z/num_jnts)]
num_joints = int(num_jnts)
cmds.pickWalk(d="up")
if(noOfjoints<2):
cmds.warning("Must create atleast 1 segment")
else:
for jnt in range(1,num_joints):
newJoint = cmds.insertJoint(src_joint)
newJoint = cmds.rename(newJoint, "tempName"+ str(jnt))
cmds.move(splitPos[0],splitPos[1],splitPos[2],newJoint+".scalePivot",newJoint+".rotatePivot",ws=True,r=True)
src_joint = newJoint
cmds. select(newJoint)
def splitJoint ():
_newBoneNum = cmds.intSlider ('boneNum', query = 1, value = 1)
_bone = cmds.ls (selection = 1, long = 1)
_childJoint = cmds.listRelatives (children = 1)
if (len (_bone) > 0) and (type(_childJoint) is not NoneType) \
and (cmds.nodeType(_bone[0]) == 'joint') and (cmds.nodeType(_childJoint) == 'joint'):
_childTranslateX = cmds.getAttr ( _childJoint[0] + '.translateX' )
_childTranslateY = cmds.getAttr ( _childJoint[0] + '.translateY' )
_childTranslateZ = cmds.getAttr ( _childJoint[0] + '.translateZ' )
_newX = _childTranslateX / ( _newBoneNum + 1.0 )
_newY = _childTranslateY / ( _newBoneNum + 1.0 )
_newZ = _childTranslateZ / ( _newBoneNum + 1.0 )
for _k in range ( _newBoneNum):
_bone = cmds.insertJoint ( _bone )
cmds.toggle (localAxis =1)
cmds.xform (_bone + '.scalePivot', _bone + '.rotatePivot',
relative = 1, objectSpace = 1, translation = ( _newX, _newY, _newZ ) )
for _k in range ( _newBoneNum ): cmds.pickWalk ( direction = 'up' )
else: raiseWarning ( 'select a bone! You can do it!' )
def splitJoint (): _newBoneNum = cmds.intSlider ( 'boneNum', query = 1, value = 1 ) _bone = cmds.ls ( selection = 1, long = 1 ) _childJoint = cmds.listRelatives ( children = 1 ) if len(_bone) > 0: if type(_childJoint) is not NoneType: # print; print; print '>>> SO FAR SO GOOD'; print # <<< DEBUG ONLY LINE, CAN BE DELETED <<< ########## _bone = _bone[0] _childJoint = _childJoint[0] _childTranslateX = cmds.getAttr ( _childJoint + '.translateX' ) _childTranslateY = cmds.getAttr ( _childJoint + '.translateY' ) _childTranslateZ = cmds.getAttr ( _childJoint + '.translateZ' ) _newX = _childTranslateX / ( _newBoneNum + 1.0 ) _newY = _childTranslateY / ( _newBoneNum + 1.0 ) _newZ = _childTranslateZ / ( _newBoneNum + 1.0 ) for _k in range ( _newBoneNum ): _bone = cmds.insertJoint ( _bone ) cmds.toggle ( localAxis = 1 ) cmds.xform ( _bone + '.scalePivot', _bone + '.rotatePivot', relative = 1, objectSpace = 1, translation = ( _newX, _newY, _newZ ) ) for _k in range ( _newBoneNum ): cmds.pickWalk ( direction = 'up' ) else: raiseWarning ( 'select the bone, not a single joint' ) else: raiseWarning ( 'select the bone' )
def jointSplit(self, jointNum, jointAxis, attr):
sel = cmds.ls(selection=True, dag=True)
parent = sel[0]
child = sel[1]
jointLength = cmds.getAttr(child + attr)
translation = jointLength / (jointNum + 1)
if jointAxis == 1:
x = translation
y = z = 0
elif jointAxis == 2:
y = translation
x = z = 0
elif jointAxis == 3:
z = translation
x = y = 0
for i in range(1, jointNum + 1):
newJoint = cmds.insertJoint(parent)
newJoint = cmds.rename(newJoint, 'split' + str(i))
cmds.move(x,
y,
z,
newJoint + '.scalePivot',
newJoint + '.rotatePivot',
relative=True,
objectSpace=True)
parent = newJoint
cmds.select(newJoint)
print('Split ' + parent + ' into ' + str(jointNum + 1) + ' joints')
def splitJoint (joint, split, prefix):
# Determine Amount of Spacing
childJoint = cmds.listRelatives (joint, c = True, type = 'joint')[0]
spacing= (cmds.getAttr (childJoint +".translateX") / split)
# Split Joint
for x in range (1, split) :
newJoint = cmds.insertJoint (joint)
cmds.setAttr (newJoint + ".translateX", spacing)
newJoint = cmds.rename (newJoint, (prefix +"_" + str(x) + "_joint"))
joint = newJoint
cmds.setAttr (childJoint + ".translateX", spacing)
def mmInsertJoint(*args):
def normalize(vector_value):
length = math.sqrt(vector_value[0]**2 + vector_value[1]**2 +
vector_value[2]**2)
x = vector_value[0] / length
y = vector_value[1] / length
z = vector_value[2] / length
result = [x, y, z]
return result
num_joints = input(10)
num_joints = num_joints + 1
joint_list = cmds.ls(sl=True)
for r in joint_list:
first_joint_trans = cmds.xform(r, q=True, ws=True, t=True)
first_joint_ori = cmds.xform(r, q=True, ws=True, ro=True)
end_joint = cmds.listRelatives(r, f=True, c=True)
end_joint_rename = cmds.rename(end_joint[0], "end_to_delete______yeah")
end_joint_trans = cmds.xform(end_joint_rename, q=True, ws=True, t=True)
end_joint_ori = cmds.xform(end_joint_rename, q=True, ws=True, ro=True)
between_vector = [
-(first_joint_trans[0] - end_joint_trans[0]),
-(first_joint_trans[1] - end_joint_trans[1]),
-(first_joint_trans[2] - end_joint_trans[2])
]
vector_length = mel.eval(
("mag(<<" + str(between_vector[0]) + "," + str(between_vector[1]) +
"," + str(between_vector[2]) + ">>)"))
vector_normalize = normalize(between_vector)
for i in range(num_joints):
vector_to_add = [
(vector_normalize[0] * ((vector_length / num_joints) *
((num_joints - float(i))))),
(vector_normalize[1] * ((vector_length / num_joints) *
((num_joints - float(i))))),
(vector_normalize[2] * ((vector_length / num_joints) *
((num_joints - float(i)))))
]
inset_joint = cmds.insertJoint(r)
cmds.joint(inset_joint,
e=True,
co=True,
o=(0, 0, 0),
p=((first_joint_trans[0] + vector_to_add[0]),
(first_joint_trans[1] + vector_to_add[1]),
(first_joint_trans[2] + vector_to_add[2])))
cmds.delete(end_joint_rename)
def insert_joints(joints=None, joint_count=1):
"""Inserts joints evenly spaced along a bone.
:param joints: List of joints to insert child joints to.
:param joint_count: Number of joints to insert.
:return: List of joints created.
"""
if joints is None:
joints = cmds.ls(sl=True, type="joint")
if not joints:
raise RuntimeError("No joint selected")
if joint_count < 1:
raise RuntimeError("Must insert at least 1 joint.")
result = []
for joint in joints:
children = cmds.listRelatives(joint, children=True, type="joint")
if not children:
raise RuntimeError(
"Joint {} needs a child in order to insert joints".format(
joint))
name = joint
end_joint = children[0]
d = distance(joint, children[0])
increment = d / (joint_count + 1)
direction = vector_to(joint, end_joint)
direction.normalize()
direction *= increment
for i in range(joint_count):
position = cmds.xform(joint,
query=True,
worldSpace=True,
translation=True)
position = OpenMaya.MPoint(position[0], position[1], position[2])
position += direction
joint = cmds.insertJoint(joint)
joint = cmds.rename(joint, ("{}_seg#".format(name)))
cmds.joint(
joint,
edit=True,
component=True,
position=(position.x, position.y, position.z),
)
result.append(joint)
return result
def InsertJoint(*args):
OrientJoint()
parentRadius = GetParentRadius()
segments = GetFieldValue()
mainJoint = GetSelection()
distance = GetDistance()
distanceSegments = distance / segments
jointToInsert = segments - 1
i = 1
prevJoint = mainJoint
while i <= jointToInsert:
newJoint = cmds.insertJoint(prevJoint)
cmds.joint(newJoint,
edit=True,
co=True,
r=True,
p=(distanceSegments, 0, 0),
rad=(parentRadius))
prevJoint = newJoint
i += 1
global mainWindow
cmds.deleteUI(mainWindow)
def rigRope(arg=None):
#input
num_joints = int(mc.textField(num_joints_input, q=True, tx=True))
num_ctrls = int(mc.textField(num_ctrls_input, q=True, tx=True))
is_stretchy = mc.checkBox(is_stretchy_input, q=1, v=1)
#save selection
cyl = mc.ls(sl=1)[0]
#deselect
mc.select(d=1)
#get start end values for joint
bbox = mc.exactWorldBoundingBox(cyl)
cyl_pivot = mc.xform(cyl, q=1, t=1)
cyl_start = cyl_pivot[0], bbox[1], cyl_pivot[2]
cyl_end = cyl_pivot[0], bbox[4], cyl_pivot[2]
#create and orient joint
joint_start = mc.joint(p=cyl_start)
joint_end = mc.joint(p=cyl_end)
mc.joint(joint_start, e=True, zso=True, oj='xyz')
mc.joint(joint_end, e=True, zso=True, oj='xyz')
#mc.setAttr(joint_start + ".visibility", 0)#hide joint
#split joint
space = (cyl_end[1] - cyl_start[1]) / num_joints
prev_joint = joint_start
for i in range(num_joints - 1):
new_joint = mc.insertJoint(prev_joint)
mc.move(space, new_joint, y=1, r=1)
prev_joint = new_joint
mc.move(cyl_end[0], cyl_end[1], cyl_end[2], joint_end, a=1, ws=1)
#set spline ik
ik_handle = mc.ikHandle(sj=joint_start,
ee=joint_end,
sol='ikSplineSolver',
ccv=1,
roc=1,
scv=1)[0]
#get curve
ik_curve_shape = mc.ikHandle(q=1, c=1)
ik_curve = mc.listRelatives(ik_curve_shape, p=1)[0]
mc.setAttr(ik_handle + ".visibility", 0) #hide ik handle
mc.setAttr(ik_curve + ".visibility", 0) #hide ik curve
#stretchy joints
if (is_stretchy):
#create curve info node and add attr
curve_info_node = mc.arclen(ik_curve, ch=1)
mc.addAttr(curve_info_node,
longName='normalizedScale',
attributeType='float')
print(curve_info_node)
curve_length = mc.getAttr(curve_info_node + '.arcLength')
#create multiply/divide node
divide_node = mc.createNode('multiplyDivide',
n=ik_curve + '_normalizedScale')
mc.setAttr(divide_node + ".operation", 2)
#make connections
mc.connectAttr(curve_info_node + ".arcLength",
divide_node + ".input1X")
mc.setAttr(divide_node + ".input2X", curve_length)
mc.connectAttr(divide_node + ".outputX",
curve_info_node + ".normalizedScale")
#connect to joints scaleY
chain_joints = mc.ikHandle(ik_handle, q=1, jl=1)
for jnt in chain_joints:
mc.connectAttr(curve_info_node + ".normalizedScale",
jnt + ".scaleY")
#bind cylinder to joints
mc.bindSkin(cyl, joint_start)
#create floating joints and ctrls
circle_ctrl = mc.circle(nr=(0, 1, 0), c=cyl_start, r=0.5)
mc.xform(circle_ctrl, cp=1)
#base
base_ctrl = mc.duplicate(circle_ctrl, n='base_jnt_Ctrl')
mc.select(d=1)
base_joint = mc.joint(p=cyl_start, n='base_joint')
mc.parent(base_joint, base_ctrl)
mc.setAttr(base_joint + ".visibility", 0) #hide joint
#tip
tip_ctrl = mc.duplicate(circle_ctrl, n='tip_jnt_Ctrl')
mc.move(cyl_end[1] - cyl_start[1], tip_ctrl, y=1, r=1)
mc.select(d=1)
tip_joint = mc.joint(p=cyl_end, n='tip_joint')
mc.parent(tip_joint, tip_ctrl)
mc.setAttr(tip_joint + ".visibility", 0) #hide joint
#mid
space = (cyl_end[1] - cyl_start[1]) / (num_ctrls - 1)
mid_joints = []
parent_ctrl = base_ctrl
for i in range(num_ctrls - 2):
mid_ctrl = mc.duplicate(circle_ctrl,
n='mid_joint' + str(i + 1) + '_Ctrl')
mc.select(d=1)
mid_joint = mc.joint(p=cyl_start, n='mid_joint' + str(i + 1))
mc.move(space * (i + 1), mid_joint, y=1, r=1)
mc.move(space * (i + 1), mid_ctrl, y=1, r=1)
mc.parent(mid_joint, mid_ctrl)
mc.parent(mid_ctrl, parent_ctrl)
mc.setAttr(mid_joint + ".visibility", 0) #hide joint
mid_joints.append(mid_joint)
parent_ctrl = mid_ctrl
mc.parent(tip_ctrl, parent_ctrl)
mc.delete(circle_ctrl)
#bind curve to floating joints
curve_skin_cluster = mc.skinCluster(ik_curve, base_joint, tip_joint)
for jnt in mid_joints:
mc.skinCluster(curve_skin_cluster, e=1, ai=jnt)
#create master ctrl
#double circle
large_circle = mc.circle(nr=(0, 1, 0), c=cyl_start, n='Rope_MASTER_Ctrl')
small_circle = mc.circle(nr=(0, 1, 0),
c=cyl_start,
r=0.85,
n='smallCircle')
circle_shape = mc.listRelatives(small_circle, s=1)
mc.parent(circle_shape, large_circle, add=1, s=1)
mc.xform(large_circle, cp=1)
mc.makeIdentity(apply=True, t=1, r=1, s=1, n=0)
mc.delete(small_circle)
mc.parent(base_ctrl, large_circle)
#group joint chain and parent constrain
jnt_chain_grp = mc.group(joint_start, n='jointChain_grp', w=1)
mc.parentConstraint(large_circle, jnt_chain_grp)
#group everything
mc.group(cyl,
ik_curve,
ik_handle,
large_circle,
jnt_chain_grp,
n='rope_##',
r=1)
# #############################################################################
def js_splitSelJoint(self, numSegments):
# This proc will split the selected joint into the specified number of segments #
#
if numSegments < 2:
cmds.error("The number of segments has to be greater than 1.. ")
# VARIABLES
#
joints = [""] * (0)
joint = ""
newChildJoints = [""] * (0)
count = 0
joints = cmds.ls(type='joint', sl=1)
for joint in joints:
# first check the rotation order vs. the axis the joint should be rotating around. In order for this to work
# correctly, the child joint of the joint specified must have translation values ONLY IN ONE AXIS. Let's
# and, that axis MUST be the first one in the rotation order. For example, if the joint structure is:
# upArm->loArm
# and the loArm has a translate value of 6 0 0, then upArm should have a rotation order of XYZ or XZY.
#
child = ""
child = str(self.js_getChildJoint(joint))
if len(child) == "":
cmds.error("Joint: " + str(joint) +
" has no children joints.\n")
else:
axis = ""
rotationOrder = ""
firstChar = ""
radius = float(cmds.getAttr(str(joint) + ".radius"))
axis = str(self.js_getJointAxis(child))
# now that we have the axis, we want to check and make sure the rotation order on $joint is correct.
rotOrderIndex = int(cmds.getAttr(str(joint) + ".rotateOrder"))
rotationOrder = self.js_getRotOrderString(joint)
# ** REMOVING CHECK FOR ROTATION ORDER MATCHING
# check that the rotaiton order will work.
#
#$firstChar = `substring $rotationOrder 1 1`;
#if ($axis == $firstChar)
if axis == firstChar:
childT = 0.0
tVal = 0.0
attr = ""
# the rotation order is correct! we're set!
# get the axis attr
attr = ("t" + str(axis))
# get the value of the child
childT = cmds.getAttr(str(child) + "." + str(attr))
space = float(childT / numSegments)
# create a series of locators along the joint based on the number of segments.
locators = [""] * (0)
for x in range(0, (numSegments - 1)):
tmp = cmds.spaceLocator()
locators[x] = str(tmp[0])
cmds.parent(locators[x], joint)
cmds.setAttr((locators[x] + ".t"), 0, 0, 0)
cmds.setAttr((locators[x] + "." + str(attr)),
(space * (x + 1)))
# We just want to segment the joint, nothing more.
# for each segment, we're going to insert a joint, and then move it to the position of the locator
prevJoint = str(joint)
for x in range(0, len(locators)):
# insert a joint
newJoint = cmds.insertJoint(prevJoint)
# get the position of the locator
pos = cmds.xform(locators[x], q=1, rp=1, ws=1)
# move the joint there
cmds.move(pos[0],
pos[1],
pos[2], (str(newJoint) + ".scalePivot"),
(str(newJoint) + ".rotatePivot"),
a=1,
ws=1)
# rename the new joint
newJoint = cmds.rename((newJoint),
(str(joint) + "_seg_" + str(
(x + 1)) + "_joint"))
cmds.setAttr((str(newJoint) + ".radius"), radius)
# set the rotation order
cmds.setAttr((str(newJoint) + ".rotateOrder"),
rotOrderIndex)
# set the prevJoint
prevJoint = newJoint
cmds.delete(locators)
def bendyArmSetup(self):
"""
creating bendy arm
"""
#- duplicate Shoulder... Making Bendy Arm, (Shoulder, Elbow, Wrist)
for lr in self.lrPrefix:
cmds.select('%sshoulder_jnt' %lr, r = True)
cmds.duplicate(rr = True)
cmds.rename('%sbendy_shoulder_jnt' %lr)
allDec = cmds.listRelatives('%sbendy_shoulder_jnt' %lr, ad = True, f = True)
for x in allDec:
if cmds.objectType(x) == 'orientConstraint':
cmds.delete(x)
elif 'wrist' in x:
cmds.rename(x, '%sbendy_wrist_jnt' %lr)
elif 'elbow' in x:
cmds.rename(x, '%sbendy_elbow_jnt' %lr)
bendyArmjnts = ['%sbendy_shoulder_jnt' %lr, '%sbendy_elbow_jnt' %lr, '%sbendy_elbow_end_jnt' %lr]
#- unparent the Bendy Arm
cmds.select('%sbendy_shoulder_jnt' %lr, r =True)
cmds.parent(w= True)
#- Insert jnts
numjntInBetween = 6
for i in range(len(bendyArmjnts)-2):
pos_1 = cmds.xform('%s' %bendyArmjnts[i], ws = True, t = True, q = True )
pos_2 = cmds.xform('%s' %bendyArmjnts[i+1], ws = True, t = True, q = True )
if lr == self.left:
pos_2 = [pos_2[0]-pos_1[0], pos_2[1]-pos_1[1], pos_2[2]-pos_1[2]]
cmds.insertJoint('%s' %bendyArmjnts[i])
cmds.joint('joint1', n = '%s_bendy1_jnt' %bendyArmjnts[i].split('_jnt')[0], e = True, co = True, p = [pos_1[0] + pos_2[0]/numjntInBetween, pos_1[1] + pos_2[1]/numjntInBetween, pos_1[2] + pos_2[2]/numjntInBetween])
for j in range(numjntInBetween-2):
cmds.insertJoint('%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+1))
cmds.joint('joint1', n = '%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+2), e = True, co = True, p = [pos_1[0] + (j+2)*pos_2[0]/numjntInBetween, pos_1[1] + (j+2)*pos_2[1]/numjntInBetween, pos_1[2] + (j+2)*pos_2[2]/numjntInBetween])
else:
pos_2 = [-pos_2[0]+pos_1[0], pos_2[1]-pos_1[1], pos_2[2]-pos_1[2]]
cmds.insertJoint('%s' %bendyArmjnts[i])
cmds.joint('joint1', n = '%s_bendy1_jnt' %bendyArmjnts[i].split('_jnt')[0], e = True, co = True, p = [pos_1[0] - pos_2[0]/numjntInBetween, pos_1[1] + pos_2[1]/numjntInBetween, pos_1[2] + pos_2[2]/numjntInBetween])
for j in range(numjntInBetween-2):
cmds.insertJoint('%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+1))
cmds.joint('joint1', n = '%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+2), e = True, co = True, p = [pos_1[0] - (j+2)*pos_2[0]/numjntInBetween, pos_1[1] + (j+2)*pos_2[1]/numjntInBetween, pos_1[2] + (j+2)*pos_2[2]/numjntInBetween])
#- Making Elbow=>Wrist jnt
#- Duplicate and renaming
cmds.select('%sbendy_elbow_jnt' %lr, r = True)
cmds.rename('%sbendy_shoulder_end_jnt' %lr)
cmds.duplicate(rr = True)
cmds.parent(w = True)
cmds.rename('%sbendy_elbow_jnt' %lr)
cmds.select('%sbendy_elbow_jnt|%sbendy_wrist_jnt' %(lr, lr), r = True)
cmds.rename('%sbendy_elbow_end_jnt' %lr)
cmds.delete('%sbendy_wrist_jnt' %lr)
#- Insert jnt
for i in range(len(bendyArmjnts)-2):
i = i+1
pos_1 = cmds.xform('%s' %bendyArmjnts[i], ws = True, t = True, q = True )
pos_2 = cmds.xform('%s' %bendyArmjnts[i+1], ws = True, t = True, q = True )
if lr == self.left:
pos_2 = [pos_2[0]-pos_1[0], pos_2[1]-pos_1[1], pos_2[2]-pos_1[2]]
cmds.insertJoint('%s' %bendyArmjnts[i])
cmds.joint('joint1', n = '%s_bendy1_jnt' %bendyArmjnts[i].split('_jnt')[0], e = True, co = True, p = [pos_1[0] + pos_2[0]/numjntInBetween, pos_1[1] + pos_2[1]/numjntInBetween, pos_1[2] + pos_2[2]/numjntInBetween])
for j in range(numjntInBetween-2):
cmds.insertJoint('%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+1))
cmds.joint('joint1', n = '%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+2), e = True, co = True, p = [pos_1[0] + (j+2)*pos_2[0]/numjntInBetween, pos_1[1] + (j+2)*pos_2[1]/numjntInBetween, pos_1[2] + (j+2)*pos_2[2]/numjntInBetween])
else:
pos_2 = [-pos_2[0]+pos_1[0], pos_2[1]-pos_1[1], pos_2[2]-pos_1[2]]
cmds.insertJoint('%s' %bendyArmjnts[i])
cmds.joint('joint1', n = '%s_bendy1_jnt' %bendyArmjnts[i].split('_jnt')[0], e = True, co = True, p = [pos_1[0] - pos_2[0]/numjntInBetween, pos_1[1] + pos_2[1]/numjntInBetween, pos_1[2] + pos_2[2]/numjntInBetween])
for j in range(numjntInBetween-2):
cmds.insertJoint('%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+1))
cmds.joint('joint1', n = '%s_bendy%s_jnt' %(bendyArmjnts[i].split('_jnt')[0], j+2), e = True, co = True, p = [pos_1[0] - (j+2)*pos_2[0]/numjntInBetween, pos_1[1] + (j+2)*pos_2[1]/numjntInBetween, pos_1[2] + (j+2)*pos_2[2]/numjntInBetween])
#- IK Spline Curve
bendyShoulderPos = cmds.xform('%s' %bendyArmjnts[0], ws = True, t = True, q = True )
bendyShoulderElbowMiddlePos = cmds.xform('%s_bendy%s_jnt' %(bendyArmjnts[0].split('_jnt')[0], numjntInBetween/2), ws = True, t = True, q = True )
bendyElbowPos = cmds.xform('%s' %bendyArmjnts[1], ws = True, t = True, q = True )
bendyElbowWristMiddlePos = cmds.xform('%s_bendy%s_jnt' %(bendyArmjnts[1].split('_jnt')[0], numjntInBetween/2), ws = True, t = True, q = True )
bendyWristPos = cmds.xform('%s' %bendyArmjnts[2], ws = True, t = True, q = True )
cmds.curve(n = '%sshoulder_elbow_ikSplineCV' %lr, d = 2, p = [(bendyShoulderPos[0], bendyShoulderPos[1], bendyShoulderPos[2]), (bendyShoulderElbowMiddlePos[0], bendyShoulderElbowMiddlePos[1], bendyShoulderElbowMiddlePos[2]), (bendyElbowPos[0], bendyElbowPos[1], bendyElbowPos[2])], k = [0,0,1,1])
cmds.curve(n = '%selbow_wrist_ikSplineCV' %lr, d = 2, p = [(bendyElbowPos[0], bendyElbowPos[1], bendyElbowPos[2]), (bendyElbowWristMiddlePos[0], bendyElbowWristMiddlePos[1], bendyElbowWristMiddlePos[2]), (bendyWristPos[0], bendyWristPos[1], bendyWristPos[2])], k = [0,0,1,1])
#- IK Spline Handle
cmds.select('%sbendy_shoulder_jnt' %lr, r = True)
cmds.select('%sbendy_shoulder_end_jnt' %lr, add = True)
cmds.select('%sshoulder_elbow_ikSplineCV' %lr, add= True)
cmds.ikHandle(n = '%sshoulder_bendy_ikSpline_handle'%lr, sol = 'ikSplineSolver', ccv = False, roc = False, pcv = False)
cmds.select('%sbendy_elbow_jnt' %lr, r = True)
cmds.select('%sbendy_elbow_end_jnt' %lr, add = True)
cmds.select('%selbow_wrist_ikSplineCV' %lr, add= True)
cmds.ikHandle(n = '%selbow_bendy_ikSpline_handle'%lr, sol = 'ikSplineSolver', ccv = False, roc = False, pcv = False)
cmds.connectAttr('%swrist_jnt.rotateX' %lr, '%selbow_bendy_ikSpline_handle.twist' %lr, f = True)
cmds.connectAttr('%sshoulder_jnt.rotateX' %lr, '%sshoulder_bendy_ikSpline_handle.twist' %lr, f = True)
#- Insert Clusters
for i in range(3):
cmds.select('%sshoulder_elbow_ikSplineCV.cv[%s]' %(lr, i), r = True)
cmds.cluster(n = '%sshoulder_elbow_ikSplineCV_cluster%s' %(lr, i))
cmds.select('%selbow_wrist_ikSplineCV.cv[%s]' %(lr, i), r = True)
cmds.cluster(n = '%selbow_wrist_ikSplineCV%s' %(lr, i))
#- Making CTRLs
if lr == self.left:
ctlColor = 6
else:
ctlColor = 12
ctl = controller.circleController('%supperArm_bend_ctl' %lr, 'yz', 1, ctlColor, ['ro', 'sc', 'vi'])
ctl = controller.circleController('%slowerArm_bend_ctl' %lr, 'yz', 1, ctlColor, ['ro', 'sc', 'vi'])
cmds.select('%sbendy_shoulder_bendy%s_jnt' %(lr, numjntInBetween/2), r = True)
cmds.select('%supperArm_bend_ctl_grp' %lr, tgl = True)
cmds.pointConstraint(weight = 1)
cmds.orientConstraint(weight = 1)
cmds.select('%sbendy_elbow_bendy%s_jnt' %(lr, numjntInBetween/2), r = True)
cmds.select('%slowerArm_bend_ctl_grp' %lr, tgl = True)
cmds.pointConstraint(weight = 1)
cmds.orientConstraint(weight = 1)
cmds.delete('%supperArm_bend_ctl_grp_pointConstraint1' %lr)
cmds.delete('%supperArm_bend_ctl_grp_orientConstraint1' %lr)
cmds.delete('%slowerArm_bend_ctl_grp_pointConstraint1' %lr)
cmds.delete('%slowerArm_bend_ctl_grp_orientConstraint1' %lr)
#- Curve Length
cmds.createNode('curveInfo', n = '%supperArm_length' %lr)
cmds.createNode('curveInfo', n = '%slowerArm_length' %lr)
cmds.connectAttr('%sshoulder_elbow_ikSplineCV.worldSpace' %lr, '%supperArm_length.inputCurve' %lr)
cmds.connectAttr('%selbow_wrist_ikSplineCV.worldSpace' %lr, '%slowerArm_length.inputCurve' %lr)
#- Original Length
#- Locators for measuring distance
bendyLoc = ['shoulder', 'elbow', 'wrist']
cmds.createNode('transform', n = '%sarm_bendy_loc_grp' %lr)
cmds.setAttr('%sarm_bendy_loc_grp.visibility' %lr, 0)
for loc in bendyLoc:
cmds.spaceLocator(n = '%sbendy_%s_loc' %(lr, loc))
cmds.select('%s%s_jnt' %(lr, loc), r = True)
cmds.select('%sbendy_%s_loc' %(lr, loc), tgl = True)
cmds.pointConstraint(weight = 1)
self.util.parent('%sbendy_%s_loc' %(lr, loc), '%sarm_bendy_loc_grp' %lr)
#- Distance, need to use global_ctl's scale
cmds.shadingNode('distanceBetween', n = '%sbendyArm_upperLength' %lr, asUtility = True)
cmds.shadingNode('distanceBetween', n = '%sbendyArm_lowerLength' %lr, asUtility = True)
cmds.connectAttr('%sbendy_shoulder_loc.translate' %lr,'%sbendyArm_upperLength.point1' %lr )
cmds.connectAttr('%sbendy_elbow_loc.translate' %lr, '%sbendyArm_upperLength.point2' %lr )
cmds.connectAttr('%sbendy_elbow_loc.translate' %lr, '%sbendyArm_lowerLength.point1' %lr )
cmds.connectAttr('%sbendy_wrist_loc.translate' %lr, '%sbendyArm_lowerLength.point2' %lr )
cmds.shadingNode('multiplyDivide', n = '%sbendy_globalScale' %lr, asUtility = True)
cmds.connectAttr('global_ctl.scaleX', '%sbendy_globalScale.input1X' %lr)
cmds.connectAttr('global_ctl.scaleX', '%sbendy_globalScale.input1Y' %lr)
cmds.connectAttr('%sbendyArm_upperLength.distance' %lr, '%sbendy_globalScale.input2X' %lr)
cmds.connectAttr('%sbendyArm_lowerLength.distance' %lr, '%sbendy_globalScale.input2Y' %lr)
#- Stretch Ratio
cmds.shadingNode('multiplyDivide', n = '%sbendyArm_stretchRatio' %lr, asUtility = True)
cmds.setAttr('%sbendyArm_stretchRatio.operation' %lr, 2)
cmds.connectAttr('%sbendy_globalScale.outputX' %lr, '%sbendyArm_stretchRatio.input2X' %lr)
cmds.connectAttr('%sbendy_globalScale.outputY' %lr, '%sbendyArm_stretchRatio.input2Y' %lr)
cmds.connectAttr('%supperArm_length.arcLength' %lr, '%sbendyArm_stretchRatio.input1X' %lr)
cmds.connectAttr('%slowerArm_length.arcLength' %lr, '%sbendyArm_stretchRatio.input1Y' %lr)
#-Bendy Stretch Condition
cmds.shadingNode('condition', n = '%sbendyArm_upperCondition' %lr, asUtility = True)
cmds.shadingNode('condition', n = '%sbendyArm_lowerCondition' %lr, asUtility = True)
cmds.setAttr('%sbendyArm_upperCondition.secondTerm' %lr, 1)
cmds.setAttr('%sbendyArm_lowerCondition.secondTerm' %lr, 1)
cmds.setAttr('%sbendyArm_upperCondition.operation' %lr, 3)
cmds.setAttr('%sbendyArm_lowerCondition.operation' %lr, 3)
cmds.connectAttr('%supperArm_length.arcLength' %lr, '%sbendyArm_upperCondition.firstTerm' %lr)
cmds.connectAttr('%slowerArm_length.arcLength' %lr, '%sbendyArm_lowerCondition.firstTerm' %lr)
cmds.connectAttr('%sbendyArm_upperLength.distance' %lr, '%sbendyArm_upperCondition.secondTerm' %lr)
cmds.connectAttr('%sbendyArm_lowerLength.distance' %lr, '%sbendyArm_lowerCondition.secondTerm' %lr)
cmds.connectAttr('%sbendyArm_stretchRatio.outputX' %lr, '%sbendyArm_upperCondition.colorIfTrueR' %lr)
cmds.connectAttr('%sbendyArm_stretchRatio.outputY' %lr, '%sbendyArm_lowerCondition.colorIfTrueR' %lr)
#- Grouping
self.util.group('%sbendy_shoulder_jnt' %lr, '%sbendy_shoulder_jnt_grp' %lr)
cmds.createNode('transform', n = '%sbendy_elbow_jnt_grp' %lr)
self.util.match('%sbendy_elbow_jnt_grp' %lr, '%selbow_jnt' %lr)
self.util.parent('%sbendy_elbow_jnt' %lr, '%sbendy_elbow_jnt_grp' %lr)
self.util.group(['%sbendy_elbow_jnt_grp' %lr, '%sbendy_shoulder_jnt_grp' %lr], '%sarm_bendy_jnt_grp' %lr)
self.util.group(['%sshoulder_bendy_ikSpline_handle' %lr, '%selbow_bendy_ikSpline_handle' %lr], '%sarm_bendy_splineik_grp' %lr)
self.util.parent('%sshoulder_elbow_ikSplineCV_cluster1Handle' %lr, '%supperArm_bend_ctl' %lr)
self.util.parent('%selbow_wrist_ikSplineCV1Handle' %lr, '%slowerArm_bend_ctl' %lr)
self.util.group(['%sshoulder_elbow_ikSplineCV' %lr, '%selbow_wrist_ikSplineCV' %lr], '%sarm_bendy_cv_grp' %lr)
self.util.group(['%sarm_bendy_splineik_grp' %lr, '%sarm_bendy_cv_grp' %lr, '%sarm_bendy_loc_grp' %lr], '%sarm_bendy_grp' %lr)
cmds.select('%sshoulder_jnt' %lr, r = True)
cmds.select('%sbendy_shoulder_jnt_grp' %lr, tgl = True)
cmds.pointConstraint(weight = 1, mo = True)
cmds.select('%selbow_jnt' %lr, r = True)
cmds.select('%sbendy_elbow_jnt_grp' %lr, tgl = True)
cmds.pointConstraint(weight = 1, mo = True)
cmds.orientConstraint(weight = 1, mo = True)
#- Cluster Grouping
self.util.parent('%sshoulder_elbow_ikSplineCV_cluster0Handle' %lr, '%sshoulder_jnt' %lr)
self.util.parent('%supperArm_bend_ctl_grp' %lr, '%sshoulder_jnt' %lr)
self.util.parent('%sshoulder_elbow_ikSplineCV_cluster2Handle' %lr, '%selbow_jnt' %lr)
self.util.parent('%selbow_wrist_ikSplineCV0Handle' %lr, '%selbow_jnt' %lr)
self.util.parent('%slowerArm_bend_ctl_grp' %lr, '%selbow_jnt' %lr)
self.util.parent('%selbow_wrist_ikSplineCV2Handle' %lr, '%swrist_jnt' %lr)
#cmds.select('%sshoulder_elbow_ikSplineCV' %lr, r = True)
#cmds.select('%sShoulder' %lr, tgl = True)
#cmds.parent()
#cmds.parent('%selbow_wrist_ikSplineCV' %lr, r = True)
#cmds.select('%sShoulder' %lr, tgl = True)
#cmds.parent()
bendyShoulderDest = cmds.listRelatives('%sbendy_shoulder_jnt_grp' %lr, ad = True)
bendyShoulderDest = bendyShoulderDest[2:-1]
bendyElbowDest = cmds.listRelatives('%sbendy_elbow_jnt_grp' %lr, ad = True)
bendyElbowDest = bendyElbowDest[2:-1]
for joint in bendyShoulderDest:
cmds.connectAttr('%sbendyArm_upperCondition.outColorR' %lr, '%s.scaleX' %joint)
for joint in bendyElbowDest:
cmds.connectAttr('%sbendyArm_lowerCondition.outColorR' %lr, '%s.scaleX' %joint)
cmds.setAttr('%sshoulder_bendy_ikSpline_handle.visibility' %lr, 0)
cmds.setAttr('%selbow_bendy_ikSpline_handle.visibility' %lr, 0)
cmds.setAttr('%sshoulder_elbow_ikSplineCV_cluster0Handle.visibility' %lr, 0)
cmds.setAttr('%sshoulder_elbow_ikSplineCV_cluster1Handle.visibility' %lr, 0)
cmds.setAttr('%sshoulder_elbow_ikSplineCV_cluster2Handle.visibility' %lr, 0)
cmds.setAttr('%selbow_wrist_ikSplineCV0Handle.visibility' %lr, 0)
cmds.setAttr('%selbow_wrist_ikSplineCV1Handle.visibility' %lr, 0)
cmds.setAttr('%selbow_wrist_ikSplineCV2Handle.visibility' %lr, 0)
cmds.addAttr('%s%s' %(lr, self.extraCtl), ln = 'Bend', at = 'long', min = 0, max = 1)
cmds.setAttr('%s%s.Bend' %(lr, self.extraCtl), e = True, keyable = True)
cmds.connectAttr('%s%s.Bend' %(lr, self.extraCtl), '%supperArm_bend_ctl_grp.visibility' %lr)
cmds.connectAttr('%s%s.Bend' %(lr, self.extraCtl), '%slowerArm_bend_ctl_grp.visibility' %lr)
#- Stretch and Bend
cmds.shadingNode('multiplyDivide', n = '%sArm_StretchBend' %lr, asUtility = True)
cmds.connectAttr('%sarm_stretchYesNo_mux.outputR' %lr, '%sArm_StretchBend.input1X' %lr)
cmds.connectAttr('%sarm_stretchYesNo_mux.outputR' %lr, '%sArm_StretchBend.input1Y' %lr)
bendyShoulderDest = cmds.listRelatives('%sbendy_shoulder_jnt_grp' %lr, ad = True)
bendyShoulderDest = bendyShoulderDest[2:-1]
bendyElbowDest = cmds.listRelatives('%sbendy_elbow_jnt_grp' %lr, ad = True)
bendyElbowDest = bendyElbowDest[2:-1]
#print bendyShoulderDest
#print bendyElbowDest
cmds.connectAttr('%sbendyArm_upperCondition.outColorR' %lr, '%sArm_StretchBend.input2X' %lr)
cmds.connectAttr('%sbendyArm_lowerCondition.outColorR' %lr, '%sArm_StretchBend.input2Y' %lr)
for joint in bendyShoulderDest:
cmds.connectAttr('%sArm_StretchBend.outputX' %lr, '%s.scaleX' %joint, f = True)
for joint in bendyElbowDest:
cmds.connectAttr('%sArm_StretchBend.outputY' %lr, '%s.scaleX' %joint, f = True)
cmds.select('%sstretch_arm_grp' %lr, r = True)
cmds.setAttr('%sstretch_arm_grp.visibility' %lr, 0)
