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 create( self, _jointchain=None ) : # print self.tree_root() self.splineikrig.create( _jointchain ) self.fkrig.create( _jointchain ) # now we'll connect the two rigs # first hide the start and end controls of teh fkrig self.fkrig.tree_children( 'rigControl' )[0].zero_group().hide() self.fkrig.tree_children( 'rigControl' )[-1].zero_group().hide() # now we can parent the upper spline control to the last fk rigjoint pm.parentConstraint( [ self.fkrig.tree_children( 'jointchain' )[0].rigjoints[-1], self.splineikrig.tree_children( 'rigControl' )[-1].zero_group() ], mo=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 immediateParent(**kwargs):
"""
Insert an immediate parent node to the selected object with
the selected object position as reference to parent
"""
group_name = kwargs.get("name", "null")
sel_obj = pm.ls(selection=True)
if not sel_obj:
pm.group(name=group_name)
return None
for obj in sel_obj:
parent_node = pm.listRelatives(obj, parent=True)
pm.select(clear=True)
group_name = str(obj) + "_Znode"
null = pm.group(name=group_name)
pm.parentConstraint(obj, null, maintainOffset=False, name="temp_const")
pm.delete("temp_const")
if parent_node:
pm.parent(null, parent_node)
pm.parent(obj, null)
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 motion_path(**kwargs):
objs = kwargs.get("objs", None)
point = int(len(objs) / 2)
print objs[point]
loc = pm.spaceLocator(name="up_loc")
tmp_con = pm.parentConstraint(objs[point], loc, maintainOffset=False)
pm.delete(tmp_con)
pm.move(loc, 10, moveY=True, objectSpace=True)
parts = 1.0 / float((len(objs) - 1))
crv = kwargs.get("path_curve", None)
print objs
#print crv
initU = 0.0
pm.select(clear=True)
#for obj in objs:
#path_anim = pm.pathAnimation(obj, curve = crv, follow=True, followAxis = "x", upAxis = "y",
# worldUpType = "object", worldUpObject = loc, fractionMode=True)
#path_anim = pm.pathAnimation(obj, curve = crv, follow=True, followAxis = "x", upAxis = "y",
# worldUpType = "vector", worldUpVector = [0,1,0], fractionMode=True)
#pm.disconnectAttr(str(path_anim)+".uValue")
#pm.setAttr(str(path_anim)+".uValue", initU)
#initU += float(parts)
return None
import pymel.all as pm
sel = pm.ls(sl=True)
src = sel.pop(0)
cpos = pm.ClosestPointOnSurface()
pm.connectAttr( src.getShape().worldSpace, cpos.inputSurface )
pm.select(None)
for obj in sel :
cpos.inPosition.set( obj.getTranslation( space='world') )
uv = ( cpos.u.get(), cpos.v.get() )
print uv
fol = pm.Follicle()
src.local >> fol.inputSurface
src.getShape().worldMatrix[0] >> fol.inputWorldMatrix
fol.outRotate >> fol.getParent().rotate
fol.outTranslate >> fol.getParent().translate
fol.parameterU.set( uv[0] )
fol.parameterV.set( uv[1] )
pm.parentConstraint( fol.getParent(), obj, mo=True )
#pm.delete(cpos)
pm.select( src, sel )
def create( self, _jointchain=None ) : super( SplineIkRig, self ).create( _jointchain ) jointchain = self.tree_children( 'jointchain' )[0] # get start and end joints rigjoints = jointchain.rigjoints # # create controls and store start/end controls/rigjoints controlsdriverslist = [] for i, rigjoint in enumerate( [ rigjoints[0], rigjoints[-1] ] ) : # create control control = RigControl( n=rigjoint.name() ) control.setRotationOrder( utils.aim_axis_to_rotate_order( settings.rotationorder ), False ) control.position_to_object( rigjoint ) self.add_child( control ) # create driver joint and store it with it's corresponding control driverrigjoint = rigjoint.duplicate( n=utils.name_from_tags( rigjoint, 'spline', 'driver' ) )[0] self.add_child( driverrigjoint ) controlsdriverslist.append( ( control, driverrigjoint ) ) startjoint = jointchain.rigjoints[0] startdriver = controlsdriverslist[0][1] endjoint = jointchain.rigjoints[-1] enddriver = controlsdriverslist[-1][1] # create ik spline between them ikhandlename = utils.name_from_tags( startjoint, 'ikhandle' ) ikhandle, ikeffector, ikcurve = pm.ikHandle( startJoint=startjoint, endEffector=endjoint, solver='ikSplineSolver', numSpans=len( jointchain.rigjoints ) - 1, name=ikhandlename ) ikeffector.rename( utils.name_from_tags( endjoint, 'ikeffector' ) ) ikcurve.rename( utils.name_from_tags( startjoint, 'curve' ) ) self.add_child( ikhandle ) self.add_child( ikcurve ) # bind curve to driver joints tobind = [ ikcurve ] + [ i[1] for i in controlsdriverslist ] pm.skinCluster( tobind, bindMethod=0, maximumInfluences=len( tobind ) - 1, ) # set twist control ikhandle.dTwistControlEnable.set( True ) ikhandle.dWorldUpType.set( 4 ) startdriver.worldMatrix[0] >> ikhandle.dWorldUpMatrix enddriver.worldMatrix[0] >> ikhandle.dWorldUpMatrixEnd # parent drivers to controls for control, driver in controlsdriverslist : pm.parentConstraint( [ control, driver ], mo=False )
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)
pm.select(joint_chain, hierarchy=True)
joint_chain = pm.ls(selection=True)
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)
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.scaleConstraint(rep_chain[index], joint_chain[index], maintainOffset=False)
pm.connectAttr(
str(rep_chain[index]) + ".scale",
str(joint_chain[index]) + ".scale")
pm.select(start_jnt, hierarchy=True)
new_chain = pm.ls(selection=True)
crv = ""
#print "START", start_jnt
#print "END",end_joint
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 stretch_exp:
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")
else:
stretch_expression(joints = joint_chain, curve_info_node = crv_info_node, connect_scale = scale_stretch,
expression_name = ik_name+"_stretch_expression")
'''
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="control_joints")
#print "JNT NAME", ctr_jnt_gp
if stretch_exp:
pm.addAttr(ctrl_jnts[-1],
longName="Stretch",
attributeType="enum",
enumName="off:on",
keyable=True)
print "ATTRIBUTE TO", str(ctrl_jnts[-1])
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)
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)
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)
return None
def createCtrl(self, name):
#cameraName = camera[0].name()
cameraShape = self.camera.getShape()
# 그룹 리깅
constraint = pm.group(n=name + "_constraint", em=True)
offset = pm.group(n=name + "_offset")
shakeTransform = pm.group(n=name + "_Shake")
offsetTz = pm.group(n=name + "_offsetTz")
offsetTy = pm.group(n=name + "_offsetTy")
offsetTx = pm.group(n=name + "_offsetTx")
tz = pm.group(n=name + "_tz")
rz = pm.group(n=name + "_rz")
rx = pm.group(n=name + "_rx")
ry = pm.group(n=name + "_ry")
ctrl = pm.group(n=name + "_Ctrl")
pm.setAttr(ctrl + ".displayHandle", 1)
pm.setAttr(ctrl + ".overrideEnabled", 1)
pm.setAttr(ctrl + ".overrideColor", 7) #dark_green
# Display
dispGrp = pm.group(n=name + "_Template_Grp", em=1)
pm.parent(dispGrp, ctrl)
pm.setAttr(dispGrp + ".overrideEnabled", 1)
pm.setAttr(dispGrp + ".overrideDisplayType", 1)
pm.setAttr(dispGrp + ".overrideColor", 7) #dark_green
dispNodeList = []
dispNodeList.extend(self.displayConnect([ctrl, tz]))
dispNodeList.extend(self.displayConnect([tz, offsetTx]))
dispNodeList.extend(self.displayConnect([offsetTx, offsetTy]))
dispNodeList.extend(self.displayConnect([offsetTy, offsetTz]))
# Outline
for dispNode in dispNodeList:
dispNode.rename(name + '_' + dispNode.name())
pm.parent(dispNodeList, dispGrp)
# Add attribute
# Camera attribute
pm.addAttr(ctrl, ln="Camera", en="Option:", at="enum")
pm.setAttr(ctrl + ".Camera", e=1, channelBox=True)
pm.addAttr(ctrl,
ln="focalLength",
dv=35,
at='double',
nn="FocalLength (mm)",
keyable=True)
pm.addAttr(ctrl,
ln="overscan",
dv=1,
at='double',
nn="Overscan",
keyable=True)
pm.addAttr(ctrl,
ln="frameRange",
at='double2',
nn="Frame Range (frame)")
pm.addAttr(ctrl,
ln="startFrame",
p='frameRange',
at='double',
nn="Start Frame",
keyable=True)
pm.addAttr(ctrl,
ln="endFrame",
p='frameRange',
at='double',
nn="End Frame",
keyable=True)
# Tumble attribute
pm.addAttr(ctrl, ln="Tumble", en="Option:", at="enum")
pm.setAttr(ctrl + ".Tumble", e=1, channelBox=True)
pm.addAttr(ctrl,
ln="tumbleTranslateZ",
at='double',
nn="Tumble Translate Z",
keyable=True)
pm.addAttr(ctrl, ln="tumbleRotate", at='double3', nn="Tumble Rotate")
pm.addAttr(ctrl,
ln="tumbleRotateX",
p='tumbleRotate',
at='double',
nn="Tumble Rotate X",
keyable=True)
pm.addAttr(ctrl,
ln="tumbleRotateY",
p='tumbleRotate',
at='double',
nn="Tumble Rotate Y",
keyable=True)
pm.addAttr(ctrl,
ln="tumbleRotateZ",
p='tumbleRotate',
at='double',
nn="Tumble Rotate Z",
keyable=True)
# Shake attribute
pm.addAttr(ctrl, ln="Shake", en="Option:", at="enum")
pm.setAttr(ctrl + ".Shake", e=1, channelBox=True)
pm.addAttr(ctrl,
ln="time",
keyable=False,
at='double',
nn="Shake Time (second)")
pm.addAttr(ctrl,
ln="timeOffset",
keyable=False,
at='double',
nn="Shake Time Offset (second)")
pm.addAttr(ctrl, ln="shake1", at='double2', nn=u"Shake 1st (진폭, 주기)")
pm.addAttr(ctrl,
ln="shakeAmplitude1",
p='shake1',
at='double',
nn=u"Shake 1st (진폭)",
keyable=True)
pm.addAttr(ctrl,
ln="shakeFrequency1",
p='shake1',
at='double',
nn=u"Frequency 1st (주기)",
keyable=True)
pm.addAttr(ctrl, ln="noise1", at='double3', nn="Shake Noise 1st")
pm.addAttr(ctrl,
ln="noise1X",
p='noise1',
at='double',
nn="Shake Noise 1 X")
pm.addAttr(ctrl,
ln="noise1Y",
p='noise1',
at='double',
nn="Shake Noise 1 Y")
pm.addAttr(ctrl,
ln="noise1Z",
p='noise1',
at='double',
nn="Shake Noise 1 Z")
pm.addAttr(ctrl, ln="shake2", at='double2', nn=u"Shake 2nd (진폭, 주기)")
pm.addAttr(ctrl,
ln="shakeAmplitude2",
p='shake2',
at='double',
nn=u"Shake 2nd (진폭)",
keyable=True)
pm.addAttr(ctrl,
ln="shakeFrequency2",
p='shake2',
at='double',
nn=u"Frequency 2nd (주기)",
keyable=True)
pm.addAttr(ctrl, ln="noise2", at='double3', nn="Shake Noise 2nd")
pm.addAttr(ctrl,
ln="noise2X",
p='noise2',
at='double',
nn="Shake Noise 2 X")
pm.addAttr(ctrl,
ln="noise2Y",
p='noise2',
at='double',
nn="Shake Noise 2 Y")
pm.addAttr(ctrl,
ln="noise2Z",
p='noise2',
at='double',
nn="Shake Noise 2 Z")
pm.addAttr(ctrl,
ln="shakeTranslate",
at='double3',
nn="Shake Translate")
pm.addAttr(ctrl,
ln="shakeTranslateX",
p='shakeTranslate',
at='double',
nn="Shake Translate X",
keyable=True)
pm.addAttr(ctrl,
ln="shakeTranslateY",
p='shakeTranslate',
at='double',
nn="Shake Translate Y",
keyable=True)
pm.addAttr(ctrl,
ln="shakeTranslateZ",
p='shakeTranslate',
at='double',
nn="Shake Translate Z",
keyable=True)
pm.addAttr(ctrl, ln="shakeRotate", at='double3', nn="Shake Rotate")
pm.addAttr(ctrl,
ln="shakeRotateX",
p='shakeRotate',
at='double',
nn="Shake Rotate X",
keyable=True)
pm.addAttr(ctrl,
ln="shakeRotateY",
p='shakeRotate',
at='double',
nn="Shake Rotate Y",
keyable=True)
pm.addAttr(ctrl,
ln="shakeRotateZ",
p='shakeRotate',
at='double',
nn="Shake Rotate Z",
keyable=True)
pm.addAttr(ctrl, ln="shakeScale", at='double', dv=1.0, keyable=True)
pm.addAttr(ctrl, ln="timeScale", at='double', dv=1.0, keyable=True)
# Offset attribute
pm.addAttr(ctrl, ln="Offset", en="Option:", at="enum")
pm.setAttr(ctrl + ".Offset", e=1, channelBox=True)
pm.addAttr(ctrl,
ln="offsetTranslate",
at='double3',
nn="Offset Translate")
pm.addAttr(ctrl,
ln="offsetTranslateX",
p='offsetTranslate',
at='double',
nn="Offset Translate X",
keyable=True)
pm.addAttr(ctrl,
ln="offsetTranslateY",
p='offsetTranslate',
at='double',
nn="Offset Translate Y",
keyable=True)
pm.addAttr(ctrl,
ln="offsetTranslateZ",
p='offsetTranslate',
at='double',
nn="Offset Translate Z",
keyable=True)
pm.addAttr(ctrl, ln="offsetRotate", at='double3', nn="Offset Rotate")
pm.addAttr(ctrl,
ln="offsetRotateX",
p='offsetRotate',
at='double',
nn="Offset Rotate X",
keyable=True)
pm.addAttr(ctrl,
ln="offsetRotateY",
p='offsetRotate',
at='double',
nn="Offset Rotate Y",
keyable=True)
pm.addAttr(ctrl,
ln="offsetRotateZ",
p='offsetRotate',
at='double',
nn="Offset Rotate Z",
keyable=True)
# Display attribute
pm.addAttr(ctrl, ln="Display", en="Option:", at="enum")
pm.setAttr(ctrl + ".Display", e=1, channelBox=True)
pm.addAttr(ctrl,
ln="cameraScale",
dv=1,
at='double',
nn="Camera Scale",
keyable=True)
pm.addAttr(ctrl,
en="off:on:",
nn="Display Ctrler",
ln="displayCtrler",
keyable=1,
at="enum",
dv=1)
# Connect Attr
pm.connectAttr(ctrl + ".cameraScale", name + ".sx")
pm.connectAttr(ctrl + ".cameraScale", name + ".sy")
pm.connectAttr(ctrl + ".cameraScale", name + ".sz")
pm.connectAttr(ctrl + ".focalLength", cameraShape + ".focalLength")
pm.connectAttr(ctrl + ".overscan", cameraShape + ".overscan")
pm.connectAttr(ctrl + ".tumbleRotateX", rx + ".rx")
pm.connectAttr(ctrl + ".tumbleRotateY", ry + ".ry")
pm.connectAttr(ctrl + ".tumbleRotateZ", rz + ".rz")
pm.connectAttr(ctrl + ".tumbleTranslateZ", tz + ".tz")
pm.connectAttr(ctrl + ".offsetTranslateX", offsetTx + ".tx")
pm.connectAttr(ctrl + ".offsetTranslateY", offsetTy + ".ty")
pm.connectAttr(ctrl + ".offsetTranslateZ", offsetTz + ".tz")
pm.connectAttr(ctrl + ".offsetRotate", offset + ".r")
pm.connectAttr(ctrl + ".displayCtrler", dispGrp + ".v")
# Lock and Hide unused attr
attrList = [
"_ry.tx", "_ry.ty", "_ry.tz", "_ry.rx", "_ry.rz", "_ry.sx",
"_ry.sy", "_ry.sz", "_ry.v", "_rx.tx", "_rx.ty", "_rx.tz",
"_rx.ry", "_rx.rz", "_rx.sx", "_rx.sy", "_rx.sz", "_rx.v",
"_rz.tx", "_rz.ty", "_rz.tz", "_rz.rx", "_rz.ry", "_rz.sx",
"_rz.sy", "_rz.sz", "_rz.v", "_tz.tx", "_tz.ty", "_tz.rx",
"_tz.ry", "_tz.rz", "_tz.sx", "_tz.sy", "_tz.sz", "_tz.v",
"_offsetTx.ty", "_offsetTx.tz", "_offsetTx.rx", "_offsetTx.ry",
"_offsetTx.rz", "_offsetTx.sx", "_offsetTx.sy", "_offsetTx.sz",
"_offsetTx.v", "_offsetTy.tx", "_offsetTy.tz", "_offsetTy.rx",
"_offsetTy.ry", "_offsetTy.rz", "_offsetTy.sx", "_offsetTy.sy",
"_offsetTy.sz", "_offsetTy.v", "_offsetTz.tx", "_offsetTz.ty",
"_offsetTz.rx", "_offsetTz.ry", "_offsetTz.rz", "_offsetTz.sx",
"_offsetTz.sy", "_offsetTz.sz", "_offsetTz.v", "_offset.sx",
"_offset.sy", "_offset.sz", "_offset.v", "_Ctrl.sx", "_Ctrl.sy",
"_Ctrl.sz"
]
for attr in attrList:
pm.setAttr(name + attr, lock=True, channelBox=False, keyable=False)
pm.setAttr(cameraShape + ".orthographic",
lock=False,
channelBox=False,
keyable=True)
pm.setAttr(cameraShape + ".orthographicWidth",
lock=False,
channelBox=False,
keyable=True)
# Constraint camera
const = pm.parentConstraint(constraint,
self.camera,
n=name + '_parentConstraint')
pm.setAttr(const + ".nds", lock=True, channelBox=False, keyable=False)
pm.setAttr(const + ".int", lock=True, channelBox=False, keyable=False)
pm.setAttr(const + ".w0", lock=True, channelBox=False, keyable=False)
pm.parent(const, ctrl)
# Add and Connect message
attr = "camera"
nodes = [self.camera, ctrl]
for node in nodes:
if node.hasAttr(attr):
node.deleteAttr(attr)
pm.addAttr(node,
ln=attr,
multi=1,
attributeType="message",
indexMatters=False)
for node in nodes:
for i in range(0, 2):
pm.connectAttr('{}.message'.format(nodes[i].name()),
'{}.{}[{}]'.format(node.name(), attr, str(i)),
f=1)
# Return
self.ctrl = ctrl
uitConvertsion = self.ctrl.outputs(type="unitConversion")
for uit in uitConvertsion:
pm.rename(uit.name(), name + '_' + uit.name())
del self.extNode[:]
self.extNode.extend([
constraint, offset, shakeTransform, offsetTz, offsetTy, offsetTx,
tz, rz, rx, ry, ctrl
])
self.extNode.extend(dispNodeList)
self.extNode.extend(uitConvertsion)
pm.select(self.ctrl, r=1)
return ctrl
import pymel.all as pm
sel = pm.ls(sl=True)
src = sel.pop(0)
cpos = pm.ClosestPointOnSurface()
pm.connectAttr(src.getShape().worldSpace, cpos.inputSurface)
pm.select(None)
for obj in sel:
cpos.inPosition.set(obj.getTranslation(space='world'))
uv = (cpos.u.get(), cpos.v.get())
print uv
fol = pm.Follicle()
src.local >> fol.inputSurface
src.getShape().worldMatrix[0] >> fol.inputWorldMatrix
fol.outRotate >> fol.getParent().rotate
fol.outTranslate >> fol.getParent().translate
fol.parameterU.set(uv[0])
fol.parameterV.set(uv[1])
pm.parentConstraint(fol.getParent(), obj, mo=True)
#pm.delete(cpos)
pm.select(src, sel)
def set_control_position(self, **kwargs):
obj = kwargs.get("cur_obj", None)
ctr = kwargs.get("ctr", None)
tmp_con = pm.parentConstraint(obj, ctr, maintainOffset=False)
pm.delete(tmp_con)
return None
def meshConstrainer(constrainer, constrained):
pma.scaleConstraint(constrainer, constrained, maintainOffset=True)
pma.parentConstraint(constrainer, constrained, maintainOffset=True)
def create( self, _jointchain=None ) : super( IkRig, self ).create( _jointchain ) jointchains = self.tree_children( 'jointchain' ) if( len( jointchains ) != 1 ) : utils.err( 'IkRig children includes more than ONE jointchain. Not sure which to use. Skipping...' ) return False jointchain = jointchains[0] # create a simple joint chain simplejointchain = jointchain.duplicate_jointchain( self.PARTNAME, 'driver', _simple=True ) self.add_child( simplejointchain ) pm.PyNode( 'leftUpperArm_1_IKJ_DRIVER' ).hide() pm.PyNode( 'leftUpperArm_1_j' ).hide() for i in range( len( simplejointchain.rigjoints ) - 1 ) : # create a curve between each pair of simple rigjoints rigjoint1 = simplejointchain.rigjoints[i] rigjoint2 = simplejointchain.rigjoints[i+1] v1 = pm.datatypes.Vector( rigjoint1.getTranslation( space='world' ) ) v2 = pm.datatypes.Vector( rigjoint2.getTranslation( space='world' ) ) curvelength = float( v1.distanceTo( v2 ) ) dirvector = [ a * b for a, b in zip( ( curvelength, curvelength, curvelength ), utils.aim_axis_to_vectors( settings.rotationorder )[0] ) ] curve = pm.curve( degree=1, point=[ ( 0, 0, 0 ), dirvector # v1, v2 ], name=utils.name_from_tags( rigjoint1, 'curve' ) ) # rebuild with numspan 2 and 3 degree pm.rebuildCurve( curve, degree=3, spans=2 ) # move vtx[1] and vtx[-2] to respective ends of curve curve.cv[1].setPosition( curve.cv[0].getPosition( space='world' ), space='world' ) curve.cv[-2].setPosition( curve.cv[-1].getPosition( space='world' ), space='world' ) ribbonlength = 0.2 ribbon = pm.extrude( curve, polygon=0, useProfileNormal=1, extrudeType=0, length=ribbonlength, ch=False, name=utils.name_from_tags( rigjoint1, 'nurbs' ) )[0] ribbon.setTranslation( ( 0, 0, -(ribbonlength)/2 ) ) ribbon.setPivots( ( 0, 0, 0 ), worldSpace=True ) pm.makeIdentity( ribbon, apply=True ) pm.delete( ribbon, ch=True ) pm.delete( curve ) utils.create_zero_sdk_groups( ribbon, _replacelast=False ) startcluster = pm.cluster( ribbon.cv[0:1][0:1], name=utils.name_from_tags( rigjoint1, 'start', 'cluster') )[1] midcluster = pm.cluster( ribbon.cv[2][0:1], name=utils.name_from_tags( rigjoint1, 'mid', 'cluster' ) )[1] endcluster = pm.cluster( ribbon.cv[-2:][0:1], name=utils.name_from_tags( rigjoint1, 'end', 'cluster' ) )[1] # parent clusters to respective rigjoints pm.parentConstraint( [ rigjoint1, startcluster ], mo=False ) pm.parentConstraint( [ rigjoint2, endcluster ], mo=False ) # group then point/parent constrain middle cluster to end clusters sdkgroup, zerogroup = utils.create_zero_sdk_groups( midcluster, _replacelast=False ) zerogroup.setRotation( rigjoint1.getRotation( space='world' ), space='world' ) pm.pointConstraint( [ rigjoint1, rigjoint2, zerogroup ], mo=False ) pm.orientConstraint( [ rigjoint1, zerogroup ], mo=False ) jointsToAttachToCurve = [ jointchain.rigjoints[i] ] jointsToAttachToCurve += jointchain.minorrigjoints[ jointsToAttachToCurve[0] ] jointsToAttachToCurve += [ jointchain.rigjoints[i+1] ] for rigjoint in jointsToAttachToCurve : p = rigjoint.getTranslation( space='world' ) posi = pm.nodetypes.ClosestPointOnSurface() ribbon.worldSpace >> posi.inputSurface posi.inPosition.set( p ) u = min( max( posi.u.get(), 0.001 ), 0.999 ) v = min( max( posi.v.get(), 0.001 ), 0.999 ) pm.delete( posi ) follicleshape = pm.nodetypes.Follicle() ribbon.local >> follicleshape.inputSurface ribbon.worldMatrix[0] >> follicleshape.inputWorldMatrix follicleshape.parameterU.set( u ) follicleshape.parameterV.set( v ) follicle = follicleshape.getParent() follicle.rename( utils.name_from_tags( rigjoint, 'follicle' ) ) follicleshape.rename( follicle.name() + 'Shape' ) follicleshape.outRotate >> follicle.rotate follicleshape.outTranslate >> follicle.translate # remove any constraints already on the joint pm.delete( rigjoint.getChildren( type='constraint' ) ) pm.parentConstraint( [ follicle, rigjoint ], mo=True ) return True
