def preBuild(self):
self.controllers['cog'] = \
ctrl.control(
name=user.prefs['cog-ctrl-name'],
shape='circle',
colour='pink',
size=5.5)
self.controllers['cogPivot'] = \
ctrl.control(
name=user.prefs['pivot-ctrl-name'],
shape='cog',
colour='purple',
size=5)
self.controllers['cog'].rotateCtrlShapes(rotate=90, axis=[0, 0, 1])
self.controllers['cog'].makeAttr(name='Pivot_Visibility', at='bool', k=False) \
>> self.controllers['cogPivot'].shape.visibility
self.controllers['cogPivot'].null.setParent(
self.controllers['cog'].ctrl)
pm.matchTransform(self.controllers['cog'].null,
self.chain[1],
pos=True,
rot=True) # position on cog placement
self.controllers['cog'].null.setParent(self.controllers['root2'])
def constrain_list(listA,listB):
#iterate through listA by index, then match it to listB?
source_list = targets[::2]
target_list = targets[1::2]
for index, object in enumerate(source_list):
print(str(object))
object_target = target_list[index]
#================== -----------
for index, source_object in enumerate(source_list):
print(str(source_object))
target_name = str(source_object).replace('fat_male', target_string)
target_object = pm.ls(target_name)[0]
pm.matchTransform(source_object, target_object, pos = True, rot = True, scale = False)
objectList = pm.ls (sl = 1)
sourceObj = objectList[0]
targetList = objectList[1:]
for target in targetList:
transformName = str(sourceObj)
currentReplacement = pm.duplicate(sourceObj)
pm.matchTransform(currentReplacement, target)
#rename?
if useTargetName == True:
#transformName = str(item)
pm.rename(currentReplacement,str(target))
else:
print('using source name')
#delete target
targetParent = str(pm.listRelatives(target, parent = True)[0])
print(targetParent)
def __add_transform_actions(cls, root_menu, selection):
pm.menuItem(
p=root_menu,
l="Create locator",
rp="E",
c=lambda *args: nodeFn.create_locator(at_object=selection[-1]),
i="locator.png")
# Match position sub menu
match_position_menu = pm.subMenuItem(p=root_menu, l="Match", rp="N")
pm.menuItem(p=match_position_menu,
l="Position",
rp="S",
c=lambda *args: pm.matchTransform(
selection[-1], selection[0], pos=True))
pm.menuItem(p=match_position_menu,
l="Rotation",
rp="SW",
c=lambda *args: pm.matchTransform(
selection[-1], selection[0], rot=True))
pm.menuItem(p=match_position_menu,
l="Object center",
rp="N",
c=lambda *args: transformFn.snap_to_object_center(
selection[0], selection[1:]))
pm.menuItem(p=match_position_menu,
l="Components center",
rp="W",
c=lambda *args: transformFn.snap_to_components_center(
selection[:-1], selection[-1]))
def makeFkChain(jnts=None):
"""Select joints in an FK chain starting with the root.
This creates a simple FK chain of controls for it."""
prev = None
ctrls = []
if not jnts:
jnts = pmc.selected(type="joint")
for j in jnts:
n = j.split("_")
n[-1] = "{0}"
n = "_".join(n)
ctrl = pmc.circle(nr=(1, 0, 0), n=n.format("ctrl"), ch=0)[0]
ctrls.append(ctrl)
ctrlGrp = pmc.group(n=n.format("offset"))
ctrlGrp.setParent(prev)
prev = ctrl
pmc.matchTransform(ctrlGrp, j)
mm = pmc.nt.MultMatrix(n=n.format("fkMtx"))
ctrl.wm >> mm.i[0]
ctrlGrp.pim >> mm.i[1]
dm = pmc.nt.DecomposeMatrix(n=n.format("fkXform"))
mm.o >> dm.imat
dm.outputTranslate >> j.t
dm.outputRotate >> j.r
#
j.addAttr("control", at="message")
ctrl.addAttr("joint", at="message")
ctrl.joint >> j.control
j.addAttr("fk_xforms", at="message")
dm.message >> j.fk_xforms
return ctrls
def create_ctl():
'''
create Facial Control and snap to bone Position
'''
if pm.objExists('ctlGp'):
pm.delete('ctlGp')
rm.create_ctl()
ul.get_node('ctlGp').setParent(ul.get_node('ROOT'))
root = {}
root['jaw'] = (ul.get_node('jaw_ctlGp'),ul.get_node('jawRoot_bon'))
root['teethUpper'] = (ul.get_node('teethUpper_ctlGp'),ul.get_node('teethUpper_bon'))
root['eye'] = (ul.get_node('eye_ctlGp'),ul.get_node('eyeLeftEnd_bon'))
for v in string.ascii_uppercase[:4]:
root['tongue%s'%v] = (ul.get_node('tongueCenter%sRoot_ctlGp'%v),ul.get_node('tongueCenter%s_bon'%v))
root['teethLower'] = (ul.get_node('teethLower_ctlGp'),ul.get_node('teethLower_bon'))
for key,(ob,target) in root.items():
#print key, ob, target
ob_pos = ob.getTranslation('world')
target_pos = target.getTranslation('world')
dest_pos = target_pos
if key == 'eye':
dest_pos = [ob_pos[0], target_pos[1], ob_pos[2]]
ob.setTranslation(dest_pos,space='world')
print 'set {} Position to {} postion'.format(ob, target)
#ob.setPivots(dest_pos, worldSpace=True)
if key != 'eye':
pm.matchTransform(ob, target, pivots=True)
pm.matchTransform(ob.getChildren()[0], target, pivots=True)
print 'match', ob, target, ob.getChildren()[0], 'to', target
pm.parentConstraint('CH_Head', 'facialRig_Gp', mo=True)
print 'Parent constraint facialRig_Gp to head'
pm.parentConstraint('CH_Head', 'eye_ctlGp', mo=True)
print 'Parent constraint eye_ctlGp to head'
def shadow_primitive():
shadow_targets = pm.ls(sl=1)
shadow_start = shadow_targets[0]
shadow_start_location = pm.xform(shadow_start,
q=True,
ws=True,
rotatePivot=True)
if shadow_start.hasAttr('radius'):
start_radius_attr = str(shadow_start) + '.radius'
shadow_radius = shadow_start.radius.get()
else:
shadow_radius = 5
#shadow_sphere = pm.sphere(radius = shadow_start_radius)
shadow_cylinder = pm.cylinder(radius=shadow_radius,
heightRatio=2,
axis=[1, 0, 0],
sections=12,
constructionHistory=1)
if len(shadow_targets) > 1:
shadow_end = shadow_targets[-1]
shadow_end_location = pm.xform(shadow_end,
q=True,
ws=True,
rotatePivot=True)
shadow_height_ratio = get_distance(shadow_start_location,
shadow_end_location)
shadow_cylinder[0].rotatePivot.set([-0.5 * shadow_height_ratio, 0, 0])
shadow_cylinder[0].scalePivot.set([-0.5 * shadow_height_ratio, 0, 0])
shadow_cylinder[1].heightRatio.set(shadow_height_ratio)
else:
pass
pm.matchTransform(shadow_cylinder, shadow_start, scale=False)
def addInput(self, node, name=None):
name = name or node.name()
input_grp = pmc.group(empty=True, name=name + '_IN')
pmc.matchTransform(input_grp, node)
pmc.parent(input_grp, self.input_group)
pmc.parentConstraint(node, input_grp, mo=True)
self.__dict__[name] = input_grp
def createLocs(subject):
loc_align = pm.spaceLocator()
pm.matchTransform(loc_align,subject, rot=True, pos=True)
loc_align.sx.set(scale)
loc_align.sy.set(scale)
loc_align.sz.set(scale)
return loc_align
def create_ctrl(node=None):
tgt = "NAME"
if node:
tgt = node.name()
else:
sel = pm.selected(type="transform")
if sel:
ctrls = []
for node in sel:
ctrls.append(create_ctrl(node))
return ctrls
ctrl_name = get_unique_name(tgt + "_CTRL")
ctrl = pm.circle(normal=[1, 0, 0], name=ctrl_name)[0]
offset_grp = pm.group(empty=True, name=ctrl_name + "_offsetGrp")
spaces_grp = pm.group(empty=True, name=ctrl_name + "_spacesGrp")
spaces_grp.setParent(offset_grp)
ctrl.setParent(spaces_grp)
if node:
pm.matchTransform(offset_grp, tgt)
pm.parentConstraint(ctrl, tgt)
ctrl.setAttr("scaleX", lock=True, keyable=False)
ctrl.setAttr("scaleY", lock=True, keyable=False)
ctrl.setAttr("scaleZ", lock=True, keyable=False)
ctrl.setAttr("visibility", lock=True, keyable=False)
return ctrl
def addOutput(self, node, name=None):
name = name or node.name()
output_grp = pmc.group(empty=True, name=name + '_OUT')
pmc.matchTransform(output_grp, node)
pmc.parent(output_grp, self.output_group)
pmc.parentConstraint(node, output_grp, mo=True)
self.__dict__[name] = output_grp
def create_bones_between_points(self,
initial_point,
final_point,
number_of_bones,
align_object=None):
direction_vector = final_point - initial_point
total_length = direction_vector.length()
step = total_length / number_of_bones
step_vector = direction_vector.normal() * step
locators_list = []
for count in range(0, number_of_bones + 1):
Locator = pm.spaceLocator()
if align_object:
if self.name_convention.is_name_in_format(align_object):
self.name_convention.rename_based_on_base_name(
align_object, Locator, name='TwistJoint')
locators_list.append(Locator)
pm.xform(Locator,
translation=list(initial_point + (step_vector * count)),
worldSpace=True)
pm.matchTransform(Locator,
align_object,
position=False,
rotation=True,
scale=False)
reset_joints, joints = self.create.joint.point_base(*locators_list,
name='twist')
self.reset_joints.append(reset_joints)
self.reset_joints[-1].setParent(self.rig_system.joints)
self.joints.extend(joints)
pm.delete(locators_list)
return self.reset_joints, self.joints
def create_scale_distance(self):
self._MODEL.getScaleGrp = [adb.makeroot_func(grp, suff='scale', forceNameConvention=True) for grp in self.jointList]
for grp in self._MODEL.getScaleGrp:
self.MOD_GRP.sx >> grp.sx
self.MOD_GRP.sy >> grp.sy
self.MOD_GRP.sz >> grp.sz
distObjs_LIST_QDT = self.ribbon_ctrl
distanceNode_shape = pm.distanceDimension(sp=(1, 1, 1), ep=(2, 2, 2))
pm.rename(distanceNode_shape, 'bendy_scale_distDimShape')
pm.rename(pm.PyNode(distanceNode_shape).getParent(), 'bendy_scale_distDim')
distanceNode = (pm.PyNode(distanceNode_shape).getParent())
end_point_loc = pm.listConnections(str(distanceNode_shape) + '.endPoint', source=True)[0]
start_point_loc = pm.listConnections(str(distanceNode_shape) + '.startPoint', source=True)[0]
pm.rename(start_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[0], NC.LOC))
pm.rename(end_point_loc, '{}_Dist__{}'.format(distObjs_LIST_QDT[1], NC.LOC))
pm.matchTransform(start_point_loc, distObjs_LIST_QDT[0])
pm.matchTransform(end_point_loc, distObjs_LIST_QDT[1])
[loc.v.set(0) for loc in [end_point_loc, start_point_loc]]
self.scale_grp = pm.group(n='{}_scale__{}'.format(self.NAME, NC.GRP), w=True, em=True)
pm.parent(distanceNode, start_point_loc, end_point_loc, self.scale_grp)
self.scale_grp.v.set(0)
return distanceNode_shape
def match_micro(source, flip = 'none'):
if source.hasAttr('microController'):
try:
joint_target = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0]
control_grp = pm.ls(str(source).replace('_CTL','_GRP'))[0]
except:
pm.warning('problem finding joint_target or control_grp')
try:
pm.delete(control_grp, constraints = 1)
pm.matchTransform(control_grp, joint_target, pos = True, rot = True, scale = False)
except:
pm.warning('failed to matchTransform')
try:
tr_constraint = pm.parentConstraint (source,joint_target, mo = 1, weight = 1)
tr_constraint.setAttr('interpType', 2)
sc_constraint = pm.scaleConstraint(source,joint_target, mo = 1, weight = 1)
except:
pm.warning('failed to constrain')
if 'x' in flip:
pm.xform(source, euler = True, rotation = [180,0,0])
elif 'y' in flip:
pm.xform(source, euler = True, rotation = [0,180,0])
elif 'z' in flip:
pm.xform(source, euler = True, rotation = [0,0,180])
else:
pm.warning('controller attr present ')
pass
elif source.hasAttr('controller'):
pm.warning("make sure this doesn't f**k anything!")
try:
joint_target = uf.meta_traverse(source = source, relation = 'child', tag = 'jointSkin')[0]
control_grp = pm.ls(str(source).replace('_CTL','_GRP'))[0]
except:
pm.warning('problem finding joint_target or control_grp')
try:
pm.delete(control_grp, constraints = 1)
pm.matchTransform(control_grp, joint_target, pos = True, rot = True, scale = False)
except:
pm.warning('failed to matchTransform')
try:
tr_constraint = pm.parentConstraint (source,joint_target, mo = 1, weight = 1)
tr_constraint.setAttr('interpType', 2)
sc_constraint = pm.scaleConstraint(source,joint_target, mo = 1, weight = 1)
except:
pm.warning('failed to constrain')
if 'x' in flip:
pm.xform(source, euler = True, rotation = [180,0,0])
elif 'y' in flip:
pm.xform(source, euler = True, rotation = [0,180,0])
elif 'z' in flip:
pm.xform(source, euler = True, rotation = [0,0,180])
else:
pm.warning('controller attr present ')
pass
pass
else:
pm.warning('no controller or microController attr')
pass
pass
def replaceShape(self, old_ctrl=pm.selected(), new_ctrl=None):
"""
Replacing shape function
@param old_ctrl: The controller that you want to change the shape
@param new_ctrl: The new shape you want to give to your old controller
"""
original_ctl = old_ctrl
colorSolver = pm.PyNode(original_ctl).overrideRGBColors.get()
if colorSolver:
color = pm.PyNode(original_ctl).overrideColorRGB.get()
else:
color = pm.PyNode(original_ctl).overrideColor.get()
@propScale
def createCtl():
ctl = new_ctrl()
pm.PyNode(ctl).overrideEnabled.set(1)
pm.PyNode(ctl).overrideRGBColors.set(colorSolver)
if isinstance(color, int):
pm.PyNode(ctl).overrideColor.set(color)
else:
pm.PyNode(ctl).overrideColorRGB.set(color)
return ctl
new_ctrl = createCtl()
new_shape = new_ctrl
# Duplicate source and move to target location
new_shape_dup = pm.duplicate(new_shape, rc=True)[0]
pm.matchTransform(new_shape_dup, original_ctl, pos=True, rot=True)
# Parent source to target's parent
pm.parent(new_shape_dup, original_ctl.getTransform())
pm.makeIdentity(new_shape_dup, apply=True, t=1, r=1, s=1)
# Get transforms and shapes of source and target
self.new_shape_getShape = pm.PyNode(new_shape_dup).getShapes()
original_ctl_getShapes = pm.PyNode(original_ctl).getShapes()
for original, new in zip(original_ctl_getShapes,
self.new_shape_getShape):
pm.rename(new, original.name())
# Parent shapes of source to target
for srcShapes in self.new_shape_getShape:
pm.parent(srcShapes, original_ctl, add=True, s=True)
# Clean up
pm.delete(new_shape_dup)
pm.delete(original_ctl_getShapes)
pm.delete(new_ctrl)
return original_ctl
def createloc(sub):
"""Creates locator at the Pivot of the object selected """
locs = []
for sel in sub:
loc_align = pm.spaceLocator(n='{}__pos_loc__'.format(sel))
locs.append(loc_align)
pm.matchTransform(loc_align, sel, rot=True, pos=True)
pm.select(locs, add=True)
return locs
def createloc(sub=pm.selected()):
"""Creates locator at the Pivot of the object selected """
locs = []
for sel in sub:
loc_align = pm.spaceLocator(n='{}_Distance__{}'.format(
NC.getNameNoSuffix(sel), NC.LOC))
locs.append(loc_align)
pm.matchTransform(loc_align, sel, rot=True, pos=True)
pm.select(locs, add=True)
return locs
def createSticky(stickyName = 'Deformer', scale = 0.2):
"""
Sticky : Creates a rivet with a softmod deformer
Returns the sticky locator
"""
rivetData = buildRivet()
rivet_trans = rivetData[0]
curveFromMeshEdgeList = rivetData[1]
MeshName = rivetData[2]
pm.PyNode(rivet_trans).v.set(0)
## master and offset grp
deformer__sys__ = pm.createNode('transform', n = '{}_{}__{}'.format(stickyName, NC.SYSTEM, NC.GRP))
deformer_offset_grp__ = pm.createNode('transform', n = '{}__offset__{}'.format(stickyName, NC.GRP))
pm.parent(deformer_offset_grp__, deformer__sys__)
## create locator
sticky_locator = pm.spaceLocator(name = '{}_sticky'.format(MeshName))
adb.changeColor_func(sticky_locator, 'index', col = 18)
pm.PyNode(sticky_locator).localScaleX.set(scale)
pm.PyNode(sticky_locator).localScaleY.set(scale)
pm.PyNode(sticky_locator).localScaleZ.set(scale)
pm.parent(sticky_locator, deformer_offset_grp__)
pm.matchTransform(deformer_offset_grp__, rivet_trans.getParent(), rot = True, pos=True)
## create softmod
softModName = '{}__softMod__'.format(stickyName)
softModDeformer = pm.softMod(MeshName,n=softModName)
pm.softMod(softModDeformer[0], edit = True, wn=(sticky_locator,sticky_locator), fas=False, fm=False )
pm.PyNode('{}HandleShape'.format(softModDeformer[0])).v.set(0)
## connect falloff Center
adb.connect_axesAttr(deformer_offset_grp__, softModDeformer[0], outputs = ['translate'], inputs = ['falloffCenter'])
deformer_offset_grp__.inverseMatrix >> softModDeformer[0].bindPreMatrix
_sticky_Attr = adbAttr.NodeAttr([sticky_locator])
_sticky_Attr.addAttr('Softmod_Falloff_Radius', 0.75, min = 0, max = 100 )
sticky_locator.Softmod_Falloff_Radius >> softModDeformer[0].falloffRadius
##giving new input geo to curveFromMeshEdges
groupPartsNodeName = pm.listConnections(softModName, t='groupParts')
for index in range(len(curveFromMeshEdgeList)):
pm.PyNode('{}GroupParts.outputGeometry'.format(softModName)) >> curveFromMeshEdgeList[index].inputMesh
adb.connect_axesAttr(rivet_trans.getParent(), deformer_offset_grp__, outputs = ['translate', 'rotate'], inputs = [])
## clean scene
pm.delete(softModDeformer[1])
pm.parent(rivet_trans.getParent(),deformer__sys__)
pm.select(clear=True)
sys.stdout.write('// Result: Sticky created // \n ')
return sticky_locator
def preBuild(self):
super(SimpleFk, self).preBuild()
ctrl_num = len(self.chain) - (1 - self.includeEndJoint)
for i in range(ctrl_num):
self.controllers[i] = (ctrl.control(name='{}_{:02d}'.format(
self.name, i + 1),
size=2))
pm.matchTransform(self.controllers[i].null, self.chain[i])
if i:
pm.parent(self.controllers[i].null,
self.controllers[i - 1].ctrl)
pm.parent(self.controllers[0].null, self.modGlobals['modCtrls'])
def match_to_geo():
"""
Helper function to match the first selected object to the second selected mesh object.
"""
user_sel = pm.ls(sl=True)
_, temp_cluster = pm.cluster(user_sel[-1])
pm.matchTransform(user_sel[0],
temp_cluster,
position=True,
rotation=False,
scale=False)
pm.delete(temp_cluster)
def placeHolderLoc(ctx=0):
'''
create locator at position of each selected object
@param ctx: 0- just snap, 1-constrain selection to loc, 2-constrain loc to selection
@return:
'''
sel = pm.selected()
for s in sel:
l = pm.spaceLocator(n=s.nodeName() + '_placeholderLoc')
if ctx == 1:
pm.parentConstraint(s, l, mo=0)
elif ctx == 2:
pm.parentConstraint(l, s, mo=0)
else:
pm.matchTransform(l, s)
def findClosestUVCoordinate(geo, obj):
closestPointOnMesh = pm.createNode("closestPointOnMesh")
geoShape = geo.getShape()
pm.connectAttr(geoShape.worldMesh, closestPointOnMesh.inMesh)
pm.connectAttr(geoShape.worldMatrix, closestPointOnMesh.inputMatrix)
loc = pm.spaceLocator(n=name.removeSuffix(geo.name()) + '_LOC')
pm.matchTransform(loc, obj)
pm.connectAttr(loc.translate, closestPointOnMesh.inPosition)
u = closestPointOnMesh.result.parameterU.get()
v = closestPointOnMesh.result.parameterV.get()
pm.delete(closestPointOnMesh, loc)
return u, v
def createPiston(parent, child, control):
"""
createPiston('joint1', 'joint2', 'Control')
"""
try:
pm.parent(child, parent)
except RuntimeError:
pass
ikNode, effector = pm.ikHandle(n='{}_IkHandle'.format(control),
sj=parent,
ee=child)
ik_group = adb.makeroot_func(ikNode, forceNameConvention=False)
pm.matchTransform(ik_group, control, pos=1, rot=0)
pm.parent(ik_group, control)
ikNode.v.set(0)
def CreateCircles():
CurveColl = []
for joint in listJoint:
myname = '{}'.format(joint)
new_name = myname.split('__jnt__')[0] + '__ctrl__'
curve = mc.circle(nr=self.Normalsctrl,
n=new_name,
r=self.RadiusCtrl)[0]
CurveColl.append(curve)
for oJoint, oCurve in zip(listJoint, CurveColl):
pm.matchTransform(oCurve, oJoint, pos=True, rot=True)
pm.parentConstraint(oCurve, oJoint, mo=True)
return CurveColl
def createDoublePiston(
lowRootjnt,
lowEndjnt,
topRootjnt,
topEndjnt,
low_ctrl,
top_ctrl,
):
"""
Creates a piston system
import adb_rig.Func__Piston as adbPiston
reload (adbPiston)
test = ['joint1', 'joint2', 'joint3', 'joint4', 'joint5__LOC', 'joint6__LOC']
"""
## create a root group over the controller
rootGrp_low = adb.makeroot_func(low_ctrl)
rootGrp_top = adb.makeroot_func(top_ctrl)
pm.parent(lowRootjnt, low_ctrl)
pm.parent(topRootjnt, top_ctrl)
## creating the Ik handles
lowIk = pm.ikHandle(
n='{}_IkHandle'.format(lowRootjnt),
sj=lowRootjnt,
ee=lowEndjnt,
)
topIk = pm.ikHandle(
n='{}_IkHandle'.format(topRootjnt),
sj=topRootjnt,
ee=topEndjnt,
)
pm.parent(lowIk[0], top_ctrl)
pm.parent(topIk[0], low_ctrl)
pm.matchTransform(lowIk[0], topRootjnt, pos=True)
pm.matchTransform(topIk[0], lowRootjnt, pos=True)
## hiding the Ik handles
pm.PyNode(topIk[1]).v.set(0)
pm.PyNode(lowIk[1]).v.set(0)
pm.PyNode(topIk[0]).v.set(0)
pm.PyNode(lowIk[0]).v.set(0)
def Mcon(src, tg, **op):
if op.get('pos'): pm.matchTransform(tg, src, pos=1, rot=1, scl=0)
mm = pm.createNode('multMatrix', n='%sMM' % tg)
dm = pm.createNode('decomposeMatrix', n='%sDM' % tg)
rtn = [None, None]
if op.get('pvtCalc'):
#tgRotatePivot=tg.getRotatePivot(space='transform')
#tg.setScalePivot(tgRotatePivot,space='transform')
tgScalePivotMtx = dt.Matrix()
tgScalePivotMtx[3] = tg.getScalePivot(space='transform')
mm.i[0].set(tgScalePivotMtx)
mm.i[1].set(tg.getMatrix(worldSpace=1))
mm.i[2].set(src.getMatrix(worldSpace=1).inverse())
src.wm >> mm.i[3]
tg.pim >> mm.i[4]
tgTMRPM = dt.Matrix()
tgTMRPM[3] = tg.transMinusRotatePivot.get()
mm.i[5].set(tgTMRPM)
else:
mm.i[0].set(tg.getMatrix(worldSpace=1))
mm.i[1].set(src.getMatrix(worldSpace=1).inverse())
src.wm >> mm.i[2]
tg.pim >> mm.i[3]
mm.o >> dm.imat
if op.get('t'):
dm.ot >> tg.t
if op.get('r'):
if tg.nodeType() == 'joint':
eq = pm.createNode('eulerToQuat', n='%sEQ' % tg)
qi = pm.createNode('quatInvert', n='%sQI' % tg)
qp = pm.createNode('quatProd', n='%sQP' % tg)
qe = pm.createNode('quatToEuler', n='%sQE' % tg)
tg.jo >> eq.irt
eq.oq >> qi.iq
dm.oq >> qp.iq1
qi.oq >> qp.iq2
qp.oq >> qe.iq
qe.ort >> tg.r
else:
dm.attr('or') >> tg.r
if op.get('s'):
dm.os >> tg.s
if op.get('sh'):
dm.osh >> tg.sh
def nurbPlaneBetweenObjects(self, Object01, Object02):
VP1 = om.MVector(pm.xform(Object01, a=True, ws=True, q=True, rp=True))
print VP1
VP2 = om.MVector(pm.xform(Object02, a=True, ws=True, q=True, rp=True))
print VP2
longitud = VP1 - VP2
plano = pm.nurbsPlane(ax=[0, 1, 0],
p=[(longitud.length()) / 2, 0, 0],
w=longitud.length(),
lr=.05,
d=3,
u=8,
v=1,
ch=0,
name="bendyPlane")
self.name_conv.rename_name_in_format(plano, useName=True)
pm.matchTransform(plano[0], Object01)
return plano[0]
def nurb_plane_between_objects(self, object_a, object_b):
vector_a = om.MVector(
pm.xform(object_a, a=True, ws=True, q=True, rp=True))
vector_b = om.MVector(
pm.xform(object_b, a=True, ws=True, q=True, rp=True))
length = vector_a - vector_b
plano = pm.nurbsPlane(ax=[0, 1, 0],
p=[(length.length()) / 2, 0, 0],
w=length.length(),
lr=.05,
d=3,
u=8,
v=1,
ch=0,
name="bendyPlane")
self.name_convention.rename_name_in_format(plano[0], useName=True)
pm.matchTransform(plano[0], object_a)
return plano[0]
def duplicateTransformHierarchyRec(origNode, parentToNode, geoProxy=False):
origChildren = origNode.getChildren(type='transform')
if len(origChildren) == 0: return 'Finished'
for origChild in origChildren:
origShape = origChild.getShape()
if origShape is not None: # shape
if geoProxy is not False:
print 'duplicating mesh'
proxySphere = pm.polySphere(name='temp', sx=4, sy=6)[0]
pm.matchTransform(proxySphere, origChild)
pm.parent(proxySphere, parentToNode)
proxySphere.rename(origChild)
else:
dup = origChild.duplicate(n='temp', po=1)[0]
pm.parent(dup, parentToNode)
dup.rename(origChild)
duplicateTransformHierarchyRec(origChild, dup, geoProxy)
def createloc(self):
"""Creates locator at the Pivot of the object selected """
if pm.selected():
try:
loc = adb.LocOnVertex()
except AttributeError:
locs = []
for sel in pm.selected():
try:
_name = sel.name().split('__')[1]
except:
_name = sel.name()
loc_align = pm.spaceLocator(n=_name + '__loc__')
locs.append(loc_align)
pm.matchTransform(loc_align, sel, rot=True, pos=True)
pm.select(locs, add=True)
return locs
else:
locs = pm.spaceLocator(n='Locator1')
return locs
def make_ctrl_at_jnt(jnt=None, axis="x"):
"""
Create a nurbs circle at the given or selected joint.
:param jnt: (optional) Joint to match xforms to.
:param axis: (optional) Joint primary axis.
:return: the nurbs control
"""
if not jnt:
jnt = pmc.selected(type="joint")[0]
n = jnt.name().split("_")
n[-1] = "{}"
n = "_".join(n)
offset = pmc.group(em=True, n=n.format("offset"))
axis = [1 if a == axis else 0 for a in "xyz"]
ctrl = pmc.circle(n=n.format("ctrl"), nr=axis, r=1.0, s=12, d=1, ch=0)[0]
ctrl.setParent(offset)
ctrl.lineWidth.set(2)
pmc.matchTransform(offset, jnt)
return ctrl
