def copyObjects(**kwargs):
"""
Input object to be copied
select positions where the objects needs be copied and run the script
the copied object constraints the position objects if options are selected
"""
print "TEST"
obj = kwargs.get("obj", "")
prFlg = kwargs.get("prFlg", False)
scFlg = kwargs.get("scFlg", False)
sel = pm.ls(selection=True, flatten=True)
ch = None
for comp in sel:
pos = pm.xform(comp, query=True, worldSpace=True, translation=True)
new_obj = pm.duplicate(obj)
pm.xform(new_obj, worldSpace=True, translation=pos)
if prFlg or scFlg:
typ = str(pm.nodeType(comp))
if typ == "transform":
ch = comp
else:
shp = pm.ls(comp, objectsOnly=True)[0]
trn = pm.listRelatives(shp, parent=True)[0]
ch = trn
if prFlg:
pm.parentConstraint(new_obj, ch, maintainOffset=True)
if scFlg:
pm.scaleConstraint(new_obj, ch, maintainOffset=True)
return None
def parent_scale_const(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctr = kwargs.get("ctr", None)
scl_flg = kwargs.get("scl_flg", False)
pm.parentConstraint(obj, ctr, maintainOffset=True)
if scl_flg:
pm.scaleConstraint(obj, ctr, maintainOffset=True)
return None
def constMult(**kwargs):
"""
parent constraint multiple child to single parent
"""
prnt = kwargs.get("prntObj", "")
prnt_con = kwargs.get("pr_cons", False)
scl_con = kwargs.get("sc_cons", False)
sel = pm.ls(selection=True)
if prnt == "":
prnt = sel.pop(0)
for obj in sel:
if prnt_con:
pm.parentConstraint(prnt, obj, maintainOffset=True)
if scl_con:
pm.scaleConstraint(prnt, obj, maintainOffset=True)
return None
def autoOrientXKeepZ(self, obj ):
assert isinstance(obj, pymel.core.nodetypes.Transform)
unrepar = Unreparenter( obj )
pm.makeIdentity( obj, apply=True, t=1, r=1, s=1, n=0, pn=1 )
target = pm.createNode('joint')
cons = [
pm.pointConstraint( obj, target ),
pm.orientConstraint( obj, target ),
pm.scaleConstraint( obj, target )
]
pm.delete( cons )
unrepar.reparent()
pm.joint( obj, edit=True,
oj='xzy', secondaryAxisOrient='yup',
zeroScaleOrient=True, children=False
)
unrepar.unparent( )
pm.makeIdentity( obj, apply=True, t=1, r=1, s=1, n=0, pn=1 )
self.rotateOnXToMatchZ(obj,target)
pm.delete( target )
pm.makeIdentity( obj, apply=True, t=1, r=1, s=1, n=0, pn=1 )
unrepar.reparent(clean=True)
def setCon(**kwargs):
"""
constraints parent child in selection set
"""
sel_obj = pm.ls(selection=True)
if not len(sel_obj) % 2 == 0:
print "please select parent child in pairs"
return None
prFlg = kwargs.get("pr_cons", False)
scFlg = kwargs.get("sc_cons", False)
pr, ch = getSet(sel=sel_obj)
pm.select(clear=True)
for prnt in pr:
index = pr.index(prnt)
if prFlg:
pm.parentConstraint(prnt, ch[index], maintainOffset=True)
if scFlg:
pm.scaleConstraint(prnt, ch[index], maintainOffset=True)
return None
def delCon(**kwargs):
"""
Delete selected constraints on selected objects if exists
"""
print "deleteCon"
sel = pm.ls(selection=True)
#con_typ = kwargs.get("constraint_type", None)
prFlg = kwargs.get("pr_con", False)
scFlg = kwargs.get("sc_con", False)
ptFlg = kwargs.get("pt_con", False)
orFlg = kwargs.get("or_con", False)
for obj in sel:
if prFlg:
const = pm.parentConstraint(obj, query=True)
if const:
pm.delete(const)
else:
print str(obj) + " parent delete skipped"
if orFlg:
const = pm.orientConstraint(obj, query=True)
if const:
pm.delete(const)
else:
print str(obj) + " orient delete skipped"
if ptFlg:
const = pm.pointConstraint(obj, query=True)
if const:
pm.delete(const)
else:
print str(obj) + " point delete skipped"
#if con_typ == "aim":
# const = pm.aimConstraint(obj, query=True)
# if const:
# pm.delete(const)
if scFlg:
const = pm.scaleConstraint(obj, query=True)
if const:
pm.delete(const)
else:
print str(obj) + " scale delete skipped"
return None
def fixJointComplexXforms( self, obj ):
assert isinstance(obj, pymel.core.nodetypes.Transform)
unrepar = Unreparenter( obj )
pm.makeIdentity( obj, apply=True, t=1, r=1, s=1, n=0, pn=1 )
tmp = pm.createNode('joint')
cons = [
pm.pointConstraint( obj, tmp ),
pm.orientConstraint( obj, tmp ),
pm.scaleConstraint( obj, tmp )
]
pm.delete( cons )
helperZ = pm.createNode('transform')
helperX = pm.createNode('transform')
pm.parent( helperX, tmp )
pm.parent( helperZ, tmp )
helperX.translate.set( [1,0,0] )
helperZ.translate.set( [0,0,1] )
obj.jointOrient.set( 0,0,0 )
obj.rotateAxis.set( 0,0,0 )
con = pm.aimConstraint( helperX, obj,
worldUpType='object',
worldUpObject=helperZ,
aimVector=[1,0,0],
upVector=[0,0,1],
)
pm.delete( con )
pm.delete( [helperX, helperZ] )
pm.delete( tmp )
pm.makeIdentity( obj, apply=True, t=1, r=1, s=1, n=0, pn=1 )
unrepar.reparent( )
def meshConstrainer(constrainer, constrained):
pma.scaleConstraint(constrainer, constrained, maintainOffset=True)
pma.parentConstraint(constrainer, constrained, maintainOffset=True)
def run(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctrl = kwargs.get("cur_ctrl", None)
ctr_mode = kwargs.get("ctr_mode", None).lower()
con_opn = kwargs.get("con_opn", None)
connect_ctrl = kwargs.get("connect_ctrl", None)
from_txt = kwargs.get("from_txt", "")
to_txt = kwargs.get("to_txt", "")
ctrl_nm_opn = kwargs.get("ctrl_nm_opn", None)
ctrl_nm_txt = kwargs.get("ctrl_nm_txt", "")
ctrl_sufx = kwargs.get("ctrl_sfx_txt", "")
zero_node_opn = kwargs.get("zero_node_opn", None)
zero_node_nm = kwargs.get("zero_nd_nm", "")
lock_scl_opn = kwargs.get("lock_scl_opn", None)
scale_check = kwargs.get("scale_check", False)
ctrl_sz_offset = str(kwargs.get("ctrl_sz_offset", "0.5"))
id_num = str(kwargs.get("id_num", ""))
position_flag = kwargs.get("obj_pos_flag", False)
pos_sel_lbl = kwargs.get("pos_sel_lbl", None)
try:
ctrl_sz_offset = float(ctrl_sz_offset)
except ValueError:
pm.displayError("invalid input for size offset value")
return None
z_frm_txt = ""
if ctrl_nm_opn:
z_frm_txt = ctrl_sufx
else:
z_frm_txt = to_txt
self.set_control_position(cur_obj=obj, ctr=ctrl)
if not position_flag:
bound_box = obj.getBoundingBox()
pos = self.get_boundary_position(bnd_bx=bound_box,
pos_sel=pos_sel_lbl)
ctr_pos = pm.xform(ctrl,
query=True,
translation=True,
worldSpace=True)
if pos_sel_lbl.find("X") > -1:
ctr_pos[0] = pos
elif pos_sel_lbl.find("Y") > -1:
ctr_pos[1] = pos
elif pos_sel_lbl.find("Z") > -1:
ctr_pos[2] = pos
#base_location = (bound_box[0])[1]
ctrl.translate.set(ctr_pos)
if scale_check:
self.scale_ctr_to_obj(cur_obj=obj,
ctr=ctrl,
size_offset=ctrl_sz_offset)
else:
self.scale_uniform(ctr=ctrl, size_offset=ctrl_sz_offset)
if not ctrl_nm_opn:
self.rename_ctrl_from_obj(cur_obj=obj,
ctr=ctrl,
replace_from_str=from_txt,
replace_to_str=to_txt)
else:
self.name_control(ctr=ctrl,
ctrl_nm=ctrl_nm_txt,
ctrl_sfx=ctrl_sufx,
id_val=id_num)
if zero_node_opn:
self.create_zero_group(ctr=ctrl,
from_nm=z_frm_txt,
zero_nm=zero_node_nm)
if connect_ctrl:
if ctr_mode == "skin":
self.skin(cur_obj=obj, ctr=ctrl)
else:
if con_opn[0]:
pm.parentConstraint(ctrl, obj, maintainOffset=True)
if con_opn[1]:
pm.scaleConstraint(ctrl, obj, maintainOffset=True)
if lock_scl_opn:
self.lock_scale_vis_rad(ctr=ctrl)
return None
def setup_ik_spline(**kwargs):
curve = kwargs.get("curve", None)
joint_chain = kwargs.get("joint_chain", None)
auto_curve = kwargs.get("auto_curve", True)
use_curve = kwargs.get("use_curve", None)
spans = kwargs.get("number_of_spans", 4)
ctrl_jnts = kwargs.get("num_control_joints", 3)
ik_name = kwargs.get("ik_name", "ikHandle")
scale_stretch = kwargs.get("scale_stretch", False)
create_dense_chain = kwargs.get("dense_chain", False)
dense_division = kwargs.get("dense_chain_divisions", 3)
auto_simplify = kwargs.get("auto_simplify_curve", False)
stretch_exp = kwargs.get("stretch_exp", False)
global_scale_check = kwargs.get("global_scale_check", False)
global_scale_attr = kwargs.get("global_scale_attr", None)
obj = None
pm.select(joint_chain, hierarchy=True)
joint_chain = pm.ls(selection=True)
for i in range(len(joint_chain)):
pm.rename(joint_chain[i], ik_name + str(i) + "_IK_JNT")
joint_chain[i] = pm.PyNode(ik_name + str(i) + "_IK_JNT")
print joint_chain
if not isinstance(joint_chain[0], pm.Joint):
pm.displayInfo("selection should be of type joint")
return None
if len(joint_chain) < 2:
pm.displayInfo("Chain should consist of more than one joint")
return None
if (global_scale_check):
if (global_scale_attr is None):
pm.displayInfo("Please input global scale attribute")
return None
else:
obj = global_scale_attr.split(".")[0]
global_attr = global_scale_attr.split(".")[1]
check_global_attr = pm.attributeQuery(global_attr,
node=obj,
exists=True)
if not check_global_attr:
pm.displayInfo("Invalid global scale attribute")
return None
start_jnt = joint_chain[0]
end_joint = joint_chain[-1]
if create_dense_chain:
rep_chain = pm.duplicate(joint_chain)
print "DUPLICATE"
for i in range(len(rep_chain)):
pm.rename(rep_chain[i], str(joint_chain[i]) + "_DnsJnt")
rep_chain[i] = pm.PyNode(str(joint_chain[i]) + "_DnsJnt")
print rep_chain
start_jnt = rep_chain[0]
end_joint = rep_chain[-1]
dense_chain(joints=rep_chain, joints_inbetween=dense_division)
rep_chain.append(end_joint)
for index in range(len(joint_chain)):
pm.parentConstraint(rep_chain[index],
joint_chain[index],
maintainOffset=False)
pm.select(start_jnt, hierarchy=True)
new_chain = pm.ls(selection=True)
crv = ""
if auto_curve:
ik_handle, eff, crv = pm.ikHandle(startJoint=start_jnt,
createCurve=auto_curve,
solver="ikSplineSolver",
numSpans=spans,
endEffector=end_joint,
simplifyCurve=auto_simplify)
else:
crv = pm.PyNode(use_curve)
ik_handle, eff = pm.ikHandle(startJoint=start_jnt,
curve=use_curve,
solver="ikSplineSolver",
endEffector=end_joint,
createCurve=False)
crv.inheritsTransform.set(0)
pm.rename(ik_handle, ik_name + "IK_Handle")
pm.rename(crv, ik_name + "IK_Curve")
ik_curve_shp = crv.getShape()
crv_info_node = pm.createNode("curveInfo")
pm.connectAttr(ik_curve_shp + ".worldSpace", crv_info_node + ".inputCurve")
if ctrl_jnts:
if ctrl_jnts == 1:
print "Minimum 2 joints needed as controllers"
print "skipping control joint creation process"
pm.displayInfo("Minimum 2 joints needed as controllers")
else:
ctrl_jnts = joints_along_curve(number_of_joints=ctrl_jnts,
curve=crv,
bind_curve_to_joint=True)
pm.select(clear=True)
ctr_jnt_gp = pm.group(ctrl_jnts,
name=ik_name + "_control_joints_GP")
for i in range(len(ctrl_jnts)):
pm.rename(ctrl_jnts[i], ik_name + str(i + 1) + "_IK_CTRL")
ctrl_jnts[i] = pm.PyNode(ik_name + str(i + 1) + "_IK_CTRL")
if stretch_exp:
pm.addAttr(ctrl_jnts[-1],
longName="Stretch",
attributeType="float",
minValue=0,
maxValue=10,
keyable=True)
print "ATTRIBUTE TO", str(ctrl_jnts[-1])
if scale_stretch:
pm.addAttr(ctrl_jnts[-1],
longName="EndDepth",
attributeType="float",
keyable=True)
pm.addAttr(ctrl_jnts[-1],
longName="Thickness",
attributeType="float",
keyable=True)
pm.addAttr(ctrl_jnts[-1],
longName="ShiftScale",
attributeType="float",
keyable=True)
if create_dense_chain:
stretch_expression(joints=new_chain,
curve_info_node=crv_info_node,
connect_scale=scale_stretch,
expression_name=ik_name + "_stretch_expression",
ctrl_attr=str(ctrl_jnts[-1]) + ".Stretch",
glbl_scl_stat=global_scale_check,
glbl_scl_attr=global_scale_attr,
control_obj=str(ctrl_jnts[-1]),
scale_joints=joint_chain)
else:
stretch_expression(joints=joint_chain,
curve_info_node=crv_info_node,
connect_scale=scale_stretch,
expression_name=ik_name + "_stretch_expression",
ctrl_attr=str(ctrl_jnts[-1]) + ".Stretch",
glbl_scl_stat=global_scale_check,
glbl_scl_attr=global_scale_attr,
control_obj=str(ctrl_jnts[-1]))
final_group = pm.group(name=ik_name + "_ik_group", empty=True)
pm.parent(joint_chain[0], final_group)
pm.parent(crv, final_group)
pm.parent(ik_handle, final_group)
if ctrl_jnts > 1:
pm.parent(ctr_jnt_gp, final_group)
if create_dense_chain:
pm.select(clear=True)
dense_grp = pm.group(start_jnt, name="dense_chain_group")
pm.parent(dense_grp, final_group)
if obj:
pm.scaleConstraint(obj, final_group)
return None