def test_shapeAttr(self):
self.assertFalse(
pm.hasAttr(self.loc, 'localPositionX', checkShape=False))
self.assertTrue(pm.hasAttr(self.loc, 'localPositionX',
checkShape=True))
self.assertFalse(self.loc.hasAttr('localPositionX', checkShape=False))
self.assertTrue(self.loc.hasAttr('localPositionX', checkShape=True))
def setViewportRGB(nodes, rgb, shape=0): isList = False if isinstance(nodes, tuple) or isinstance(nodes, list): isList = True if not isList: nodes = [nodes] for node in nodes: shapes = pm.listRelatives(node, s=True) if (shape==1 ): if len(shapes) > 0: for shape in shapes: if pm.hasAttr(shape, 'overrideColorRGB'): shape.overrideEnabled.set(1) shape.overrideDisplayType.set(0) shape.overrideRGBColors.set(1) shape.overrideColor.set(rgb) shape.overrideColor.set(rgb) else: if pm.hasAttr(node, 'overrideColorRGB'): node.overrideEnabled.set(1) node.overrideDisplayType.set(0) node.overrideRGBColors.set(1) node.overrideColorRGB.set(rgb) node.overrideColor.set(1)
def add_driver(self, treewidget, children=False):
"""
"""
userSel = pm.ls(sl=True)
itemsToAdd = []
for item in userSel:
# filtering out SDK and tweak ctls.
if pm.hasAttr(item, "is_SDK") == False:
if pm.hasAttr(item, "is_tweak") == False:
if pm.nodeType(item) == "transform":
if item not in itemsToAdd:
itemsToAdd.append(item)
AllTreeItems = self.get_tree_item_names(treewidget)
if itemsToAdd:
for item in itemsToAdd:
if item.name() not in AllTreeItems:
treeItem = self.create_item(item.name())
# --------
brush = QtGui.QBrush(QtGui.QColor(60, 60, 60))
brush.setStyle(QtCore.Qt.SolidPattern)
treeItem.setBackground(0, brush)
treeItem.setSizeHint(0, QtCore.QSize(0, 30))
pprint(dir(treeItem))
treewidget.addTopLevelItem(treeItem)
if children:
self.add_children(treeItem)
def switchLayer(layer=''):
'''
This method can be used for showing or hiding objects in the stereo layers
layer: near, main, far
'''
layers = findStereoLayers()
if not layers.has_key(layer):
return
for l in layers[layer]:
if not pm.hasAttr(l, 'stereo_layer'):
continue
if not pm.hasAttr(l, 'stereo_layer_visibility'):
pm.addAttr(l, ln='stereo_layer_visibility', at='bool')
l.stereo_layer_visibility.set(1)
objects = getObjectsFromLayer(l)
if l.stereo_layer_visibility.get():
setObjectVisibilityOff(objects)
l.stereo_layer_visibility.set(0)
else:
setObjectVisibilityOn(objects)
l.stereo_layer_visibility.set(1)
def copy_channelbox_attributes():
# copy values from selected main and shape attributes
main_channels = pm.channelBox('mainChannelBox',
q=True,
selectedMainAttributes=True)
shape_channels = pm.channelBox('mainChannelBox',
q=True,
selectedShapeAttributes=True)
# input_attr = pm.channelBox('mainChannelBox', q=True, selectedHistoryAttributes=True)
# output_attr = pm.channelBox('mainChannelBox', q=True, selectedOutputAttributes=True)
clipboard = collections.OrderedDict()
for obj in pm.ls(orderedSelection=True):
main_attr = {}
shape_attr = {}
if main_channels:
for at in main_channels:
if pm.hasAttr(obj, at):
main_attr[str(at)] = pm.getAttr(obj + '.' + at)
shape_node = obj.getShape()
if shape_channels:
for at in shape_channels:
if pm.hasAttr(obj, at):
shape_attr[str(at)] = pm.getAttr(shape_node + '.' + at)
clipboard[str(obj.fullPath())] = {
'main_attributes': main_attr,
'shape_attributes': shape_attr
}
return clipboard
def isIKFKLimb(ctl):
if not isController(ctl):
return False
if pm.hasAttr(ctl, "mp"):
if pm.listConnections(ctl + ".mp"):
metaNode = pm.listConnections(ctl + ".mp")[0]
return pm.hasAttr(metaNode, "state")
else:
return False
def doSimplify( self, parentNode ):
for node in parentNode:
childenNode = pm.listRelatives( node, c=True, typ='joint' )
if len( childenNode ):
self.doSimplify( childenNode )
print node
print pm.hasAttr( node, 'inbetweenJoints')
print pm.hasAttr( node, 'inbetweenJoints')
#pm.setAttr( (node+'.inbetweenJoints'), 0 )
return
def _connectToTarget(node, target):
# Add message attributes to the node and its target
if not pmc.hasAttr(node, 'bindTarget'):
pmc.addAttr(node, ln='bindTarget', at='message')
if not pmc.hasAttr(target, 'bindNode'):
pmc.addAttr(target, ln='bindNode', at='message')
# Connect the attributes
pmc.connectAttr(node.bindTarget, target.bindNode, force=True)
def test_intance_from_meta(self):
new_character = components.Character.create()
instance = components.Character(new_character.pynode.name())
# Assertions
# Meta node attributes
self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl"))
self.assertTrue(pm.hasAttr(instance.pynode, "characterName"))
self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl"))
self.assertTrue(pm.hasAttr(instance.pynode, "controlRig"))
self.assertTrue(pm.hasAttr(instance.pynode, "deformationRig"))
self.assertTrue(pm.hasAttr(instance.pynode, "geometryGroup"))
self.assertTrue(pm.hasAttr(instance.pynode, "locatorsGroup"))
self.assertTrue(pm.hasAttr(instance.pynode, "worldLocator"))
# Main groups
self.assertEqual(str(instance.control_rig),
names.Character.control_rig.value)
self.assertEqual(str(instance.deformation_rig),
names.Character.deformation_rig.value)
self.assertEqual(str(instance.geometry_grp),
names.Character.geometry.value)
self.assertEqual(str(instance.locators_grp),
names.Character.locators.value)
self.assertTrue(pm.objExists(instance.world_locator))
# Data struct
self.assertEqual(instance.side, "char")
self.assertEqual(instance.name, "character")
# Save test scene
pm.renameFile(
self.get_temp_filename(
"character_component_test_instance_from_meta.ma"))
pm.saveFile(f=1)
def test_create_default(self):
instance = luna_rig.components.Character.create()
# Assertions
# Metanode attributes
self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl"))
self.assertTrue(pm.hasAttr(instance.pynode, "characterName"))
self.assertTrue(pm.hasAttr(instance.pynode, "rootCtl"))
self.assertTrue(pm.hasAttr(instance.pynode, "controlRig"))
self.assertTrue(pm.hasAttr(instance.pynode, "deformationRig"))
self.assertTrue(pm.hasAttr(instance.pynode, "geometryGroup"))
self.assertTrue(pm.hasAttr(instance.pynode, "locatorsGroup"))
self.assertTrue(pm.hasAttr(instance.pynode, "worldLocator"))
# Instance members
self.assertEqual(instance.tag, "character")
self.assertEqual(str(instance.control_rig),
static.CharacterMembers.control_rig.value)
self.assertEqual(str(instance.deformation_rig),
static.CharacterMembers.deformation_rig.value)
self.assertEqual(str(instance.geometry_grp),
static.CharacterMembers.geometry.value)
self.assertEqual(str(instance.locators_grp),
static.CharacterMembers.locators.value)
self.assertTrue(pm.objExists(instance.world_locator))
# Save test scene
pm.renameFile(
self.get_temp_filename(
"character_component_test_create_default.ma"))
pm.saveFile(f=1)
def test_instance_from_meta(self):
component1 = AnimComponent.create()
new_component = AnimComponent(component1.pynode.name())
# Assertions
# Structs
self.assertEqual(new_component.name, "anim_component")
self.assertEqual(new_component.side, "c")
# Metanode
self.assertEqual(
str(new_component.pynode),
"{0}_{1}_00_meta".format(new_component.side, new_component.name))
self.assertEqual(new_component.pynode.metaRigType.get(),
AnimComponent.as_str())
self.assertEqual(new_component.pynode.version.get(), 1)
self.assertEqual(
str(new_component.root),
"{0}_{1}_00_comp".format(new_component.side, new_component.name))
self.assertEqual(
str(new_component.group_ctls),
"{0}_{1}_00_ctls".format(new_component.side, new_component.name))
self.assertEqual(
str(new_component.group_joints),
"{0}_{1}_00_jnts".format(new_component.side, new_component.name))
self.assertEqual(
str(new_component.group_parts),
"{0}_{1}_00_parts".format(new_component.side, new_component.name))
# Meta parent attrs on hierarchy
self.assertTrue(pm.hasAttr(new_component.root, "metaParent"))
self.assertTrue(pm.hasAttr(new_component.group_ctls, "metaParent"))
self.assertTrue(pm.hasAttr(new_component.group_joints, "metaParent"))
self.assertTrue(pm.hasAttr(new_component.group_parts, "metaParent"))
# Attributes on meta node
self.assertTrue(pm.hasAttr(new_component.pynode, "rootGroup"))
self.assertTrue(pm.hasAttr(new_component.pynode, "ctlsGroup"))
self.assertTrue(pm.hasAttr(new_component.pynode, "jointsGroup"))
self.assertTrue(pm.hasAttr(new_component.pynode, "partsGroup"))
# Connections to metanode
self.assertTrue(
pm.isConnected(new_component.root.metaParent,
new_component.pynode.rootGroup))
self.assertTrue(
pm.isConnected(new_component.group_ctls.metaParent,
new_component.pynode.ctlsGroup))
self.assertTrue(
pm.isConnected(new_component.group_joints.metaParent,
new_component.pynode.jointsGroup))
self.assertTrue(
pm.isConnected(new_component.group_parts.metaParent,
new_component.pynode.partsGroup))
# Save test scene
pm.renameFile(
self.get_temp_filename(
"anim_component_test_instance_from_meta.ma"))
pm.saveFile(f=1)
def __setitem__(self, key, value):
if not pm.hasAttr(self._node, key):
raise KeyError('{0} has no attribute {1}'.format(self._node, key))
attribute = self._node.attr(key)
wasLocked = attribute.isLocked()
if wasLocked:
attribute.unlock()
try:
if attribute.type() == Attribute.Type.MESSAGE:
if attribute.isMulti():
self.__setMultiMessage(attribute, value)
else:
self.__setSingleMessage(attribute, value)
else:
if attribute.isMulti():
self.__setMultiAttr(attribute, value)
else:
attribute.set(value)
except Exception as error:
raise error
finally:
if wasLocked:
attribute.lock()
def __init__(self, *args, **kwargs):
self.log = logging.getLogger(self.__class__.__name__)
if not args:
self._node = self.NODE_TYPE(**kwargs)
elif len(args) == 1:
arg = args[0]
if type(arg) == str or type(arg) == unicode:
self._node = self.NODE_TYPE(arg, **kwargs)
else:
if not isinstance(arg, self.NODE_TYPE):
raise TypeError('{0} ({1}) is not expected node type {2}.'.format(arg, type(arg), self.NODE_TYPE))
self._node = arg
else:
raise ValueError('Only one parameter permitted. Must be a Maya node reference.')
if not pm.hasAttr(self._node, MayaNode.CLASS_ATTR):
self._node.addAttr(MayaNode.CLASS_ATTR, dataType = 'string')
self._node.attr(MayaNode.CLASS_ATTR).set('{0}'.format(self.__class__))
def exposeOutput(ctrl, outputNode, rigType, unMirror=0, createJoint=1):
if pmc.hasAttr(outputNode, 'outMatrix'):
index = outputNode.outMatrix.numElements()
if unMirror:
m = unMirrorMtx(ctrl.worldMatrix[0],
name=ctrl.name().replace('ctrl', ''))
m.matrixSum.connect(outputNode.outMatrix[index])
else:
ctrl.worldMatrix[0].connect(outputNode.outMatrix[index])
if createJoint:
pmc.select(None)
j = pmc.joint(name=ctrl.name().replace('ctrl', 'Out_Jnt'))
j.segmentScaleCompensate.set(0)
pmc.addAttr(j, ln='jointIndex', at='short', k=0)
pmc.addAttr(j, ln='rigType', dt='string')
j.rigType.set(rigType)
j.jointIndex.set(index)
d = pmc.createNode('decomposeMatrix',
name=ctrl.name().replace('ctrl', 'mtx2Srt_utl'))
outputNode.outMatrix[index].connect(d.inputMatrix)
d.outputTranslate.connect(j.t)
d.outputRotate.connect(j.r)
d.outputScale.connect(j.s)
return j
def _check_created_node(cls):
"""
Catches all network nodes that are meta types. If they aren't in the meta dictionary they will be added.
Should only apply to copied meta nodes and imported meta nodes as they dont go through the normal meta node
create function. Always runs deferred, therefore this will not reliably catch metas from a batch process.
If this is needed look at using update_meta_dictionary from your batch (scene load/new will also run
update_meta_dictionary).
"""
m_obj = cls.created_m_objs.pop(0)
m_objs_uuid = om2.MFnDependencyNode(m_obj).uuid()
if m_objs_uuid.valid():
uuid = m_objs_uuid.asString()
nodes = pm.ls(uuid)
if nodes:
if pm.hasAttr(nodes[0], META_TYPE):
if nodes[0].attr(META_TYPE).get(
) in meta.core.Register.__meta_types__.keys():
metanode_class = meta.core.Register.__meta_types__[
nodes[0].attr(META_TYPE).get()]
if all(metanode.uuid != uuid
for metanode in cls.meta_dict.get(
metanode_class.meta_type, [])):
if metanode_class.meta_type not in cls.meta_dict:
cls.meta_dict[metanode_class.meta_type] = []
new_meta = metanode_class(nodes[0])
cls.meta_dict[metanode_class.meta_type].append(
new_meta)
om2.MUserEventMessage.postUserEvent(
cls.create_event,
(metanode_class.meta_type, new_meta))
new_meta.created_event()
def assert_cache(namespace, path):
cache_group = assert_group_chain('animated', '{}_group'.format(namespace), 'cache')
pm.hide(cache_group)
if not pm.hasAttr(cache_group, 'mmCachePath'):
cache_group.addAttr('mmCachePath', dataType='string')
nodes = pm.listRelatives(cache_group, children=True)
if nodes:
existing_path = cache_group.attr('mmCachePath').get()
if not existing_path:
raise ValueError("Cache group {} has children, but no mmCachePath set.".format(cache_group))
if existing_path == path:
print(' NOTE: Already up to date.')
return nodes, True
print(' WARNING: Out of date; deleting.')
pm.delete(nodes)
nodes = None
if not nodes:
before = set(pm.ls(assemblies=True))
pm.AbcImport(path, ft='{}:[^:]*$'.format(namespace))
nodes = list(set(pm.ls(assemblies=True)) - before)
for node in nodes:
pm.parent(node, cache_group)
cache_group.attr('mmCachePath').set(path)
return nodes, False
def get_current_SDKs():
"""
If SDK ctls are selected, will return only the SDK nodes
Attatched to those in the selection. If nothing is
selected, will get all the SDK nodes in the scene and return them.
Returns:
SDKs_to_set (list) - list of SDKs as Pynodes
"""
SDKs_to_set = []
all_ctls = []
user_sel = pm.ls(sl=True)
# If something selected, Get all SDK ctls in sel.
if len(user_sel) > 0:
for item in user_sel:
if pm.hasAttr(item, "is_SDK"):
if item not in all_ctls:
all_ctls.append(item)
if len(all_ctls) == 0:
pm.warning("Please select a SDK ctl")
else:
# Get all ctls with is_SDK attr
for item in pm.ls("*.is_SDK"):
SDK_ctl = item.node()
if SDK_ctl not in all_ctls:
all_ctls.append(pm.PyNode(SDK_ctl))
if all_ctls:
# getting all SDKs attatched to Ctls
for ctl in all_ctls:
for sdk, sdkInfo in sdk_io.getAllSDKInfoFromNode(ctl).items():
SDKs_to_set.append(pm.PyNode(sdk))
return SDKs_to_set
def setOutlinerRGB(nodes, rgb): if not isinstance(nodes, list): nodes = [nodes] for node in nodes: if pm.hasAttr(node, 'useOutlinerColor'): node.useOutlinerColor.set(1) node.outlinerColor.set(rgb)
def resetOutlinerRGB(nodes): if not isinstance(nodes, list): nodes = [nodes] for node in nodes: if pm.hasAttr(node, 'useOutlinerColor'): node.useOutlinerColor.set(0) node.outlinerColor.set(0,0,0)
def getLimbFkControls(metaNode, *args):
fkControls = []
if metaNode:
for attr in ["ShoulderFK", "HipFK"]:
if pm.hasAttr(metaNode, attr):
fkControls.append(pm.listConnections(metaNode + "." + attr)[0])
for attr in ["ElbowFK", "KneeFK"]:
if pm.hasAttr(metaNode, attr):
fkControls.append(pm.listConnections(metaNode + "." + attr)[0])
for attr in ["WristFK", "AnkleFK"]:
if pm.hasAttr(metaNode, attr):
fkControls.append(pm.listConnections(metaNode + "." + attr)[0])
for attr in ["FootFK"]:
if pm.hasAttr(metaNode, attr):
fkControls.append(pm.listConnections(metaNode + "." + attr)[0])
return fkControls
def paste_channelbox_attributes(data=None, objects=None):
if not data:
pm.warning('Nothing to paste from.')
return
for obj in objects:
for k, cat in data.iteritems():
for at, value in cat['main_attributes'].iteritems():
if pm.hasAttr(obj, at):
pm.setAttr(obj + '.' + at, float(value))
shape_node = obj.getShape()
if shape_node:
for at, value in cat['shape_attributes'].iteritems():
if pm.hasAttr(shape_node, at):
pm.setAttr(shape_node + '.' + at, float(value))
def _findBindNodes():
# Grab a list of every bind node in the scene
return [
obj for obj in pmc.ls(dag=True)
if pmc.hasAttr(obj, 'bindTarget', checkShape=False)
]
def find_coordinate_space_node(node):
for conn in node.attr('message').connections(d=True, s=False):
if pm.hasAttr(conn, 'nodeType') and conn.attr(
'nodeType').get() == 'CoordinateSpaceReferences':
return conn
raise Exception('Node %s doesn\'t have a coordinate space attribute.' %
node)
def addDisplayAttr(obj):
'''
Adds an attr (if needed) to control displaying the full shape or not.
'''
attrName = 'display'
shapes = core.shape.getShapes(obj)
curves = ls(shapes, type='nurbsCurve')
surfaces = ls(shapes, type='nurbsSurface')
if curves and surfaces:
if not hasAttr(obj, attrName):
obj.addAttr(attrName,
at='enum',
enumName='outline:full:surface',
k=False,
dv=1)
curveVis = createNode('condition')
obj.attr(attrName) >> curveVis.firstTerm
curveVis.secondTerm.set(2)
curveVis.operation.set(4)
curveVis.colorIfTrueR.set(1)
curveVis.colorIfFalseR.set(0)
for curve in curves:
curveVis.outColorR >> curve.visibility
obj.attr(attrName).set(cb=True)
for surface in surfaces:
obj.attr(attrName) >> surface.visibility
def delete_materials():
"""delete all material networks that have surfacing attributes"""
all_shading_groups = pm.ls(type="shadingEngine")
to_delete = []
for shading_group in all_shading_groups:
if pm.hasAttr(shading_group, ATTR_MATERIAL):
to_delete.append(shading_group)
pm.delete(to_delete)
def resetViewportColor(nodes): for node in nodes: if pm.hasAttr(node, 'overrideEnabled'): node.overrideEnabled.set(0) node.overrideDisplayType.set(0) node.overrideRGBColors.set(0) node.overrideColor.set(0, 0, 0) shapes = pm.listRelatives(sel, shapes=True) for shape in shapes: if pm.hasAttr(shape, 'overrideEnabled'): shape.overrideEnabled.set(0) shape.overrideDisplayType.set(0) shape.overrideRGBColors.set(0) shape.overrideColorR.set(0) shape.overrideColorG.set(0) shape.overrideColorB.set(0) shape.overrideColor.set(0)
def removeSelectedNodes():
nodes = [obj for obj in pmc.selected() if pmc.hasAttr(obj, 'bindTarget')]
if len(nodes) > 0:
for node in nodes:
_removeNode(node)
else:
logging.warning('No valid nodes selected')
def _setSingleConnection(obj, attrName, value):
if value:
if isinstance(value, basestring):
PyNode(value).message >> messageAttr( obj, attrName )
else:
value.message >> messageAttr( obj, attrName )
else:
if hasAttr(obj.node(), attrName):
obj.attr(attrName).disconnect()
def getOutputs():
outputDict = {}
outputs = [
node for node in pmc.ls(type='transform')
if pmc.hasAttr(node, 'outputType')
]
for output in outputs:
outputDict[output.outputType.get()] = output
return outputDict
def showLayer(layer='', show=True):
layers_list = ['main', 'near', 'far']
if not layer:
# we show all objects in the stereo layer if layer is empty
for l in layers_list:
if pm.objExists('stereo_'+l):
tmp = pm.PyNode('stereo_'+l)
tmp.attr('v').set(1)
if pm.hasAttr(tmp, 'stereo_hidden'):
for o in tmp.attr('stereo_hidden').get().split(';'):
try:
if pm.objExists(o):
pm.setAttr(o+'.overrideVisibility', 1)
pm.setAttr(o+'.overrideEnabled', 0)
except:
print traceback.format_exc()
return
for l in layers_list:
if l==layer:
if pm.objExists('stereo_'+l):
tmp = pm.PyNode('stereo_'+l)
tmp.attr('v').set(int(show))
if pm.hasAttr(tmp, 'stereo_hidden'):
for o in tmp.attr('stereo_hidden').get().split(';'):
try:
if pm.objExists(o):
pm.setAttr(o+'.overrideVisibility', int(show))
pm.setAttr(o+'.overrideEnabled', int(not show))
except:
print traceback.format_exc()
else:
if pm.objExists('stereo_'+l):
tmp = pm.PyNode('stereo_'+l)
tmp.attr('v').set(int(not show))
if pm.hasAttr(tmp, 'stereo_hidden'):
for o in tmp.attr('stereo_hidden').get().split(';'):
try:
if pm.objExists(o):
pm.setAttr(o+'.overrideEnabled', int(show))
pm.setAttr(o+'.overrideVisibility', int(not show))
except:
print traceback.format_exc()
def isOverrideAR(self, m):
if not pm.referenceQuery(m,isNodeReferenced=1):return False
ref = m.referenceFile()
if not ref:return False
refNode = ref.refNode
if not refNode:return False
if pm.hasAttr(refNode,'AROrign'):
print pm.getAttr(refNode.name()+'.AROrign')
return True
return False
def syncTextures(error=False):
oSync = Sync()
paths = set()
for fn in pym.ls(type="file"):
if pym.hasAttr(fn, "fileTextureName"):
ftn = fn.fileTextureName.get()
mapfolder = oSync.strip(pym.Path(ftn).parent)
if mapfolder not in paths:
paths.add(mapfolder)
syncPath(mapfolder)
def getObjectsFromLayer(layer):
objects = []
if not pm.objExists(layer):
return
layer = pm.PyNode(layer)
if not pm.hasAttr(layer, 'stereo_layer'):
return
obj_string = layer.stereo_layer.get()
if obj_string:
objects = [pm.PyNode(o.strip()) for o in obj_string.split(';') if pm.objExists(o.strip())]
return objects
def getSceneObjectIdList(self): #deselect all pm.select(cl = True) #list all scene objects sceneObjList = pm.ls(fl = True) #Iterate through scene objects list and if obj has vrayObjId attr then add to objIdList objIdList = [] for obj in sceneObjList: #attrs added on geometry if(pm.hasAttr(obj, 'vrayObjectID', checkShape = True)): objIdList.append(pm.getAttr(obj.vrayObjectID)) #cover vrops elif((pm.hasAttr(obj, 'objectIDEnabled')) and (pm.hasAttr(obj, 'objectID'))): if(obj.objectIDEnabled.get()): objIdList.append(pm.getAttr(obj.objectID)) #return duplicate free list return sorted(list(set(objIdList)))
def matchFkToIk(fkControls, msgAttr='ikjoints', autoKey=True):
"""
Matches fkControls to match the current pose of the underlying ik duplicate joint chains
Finds the ik joints using a previously created message connection to the attribute msgAttr
"""
ikJoints = None
switchControl = None
switchAttr = None
for ctl in fkControls:
if pmc.hasAttr(ctl, msgAttr):
ikJoints = pmc.listConnections('{0}.{1}'.format(ctl, msgAttr),
destination=False, source=True)
attr = pmc.listConnections('{0}.ikfk'.format(ctl), destination=False,
source=True, plugs=True, scn=True)[0]
switchControl = attr.node()
switchAttr = attr.name(includeNode=False)
break
if autoKey:
frameBeforeCurrent = pmc.currentTime(q=True) - 1
pmc.setKeyframe(switchControl, attribute=switchAttr, time=frameBeforeCurrent,
value=0, outTangentType='step')
pmc.setKeyframe(fkControls, attribute='rotate', time=frameBeforeCurrent,
outTangentType='step')
pmc.setKeyframe(switchControl, attribute=switchAttr, value=1, outTangentType='step')
for ikj, ctl in izip(ikJoints, fkControls):
alignObjects(ctl, ikj, position=False, rotation=True)
if autoKey:
pmc.setKeyframe(fkControls, attribute='rotate')
pmc.headsUpMessage('BAMF!')
def test_transformAttr(self):
self.assertTrue(pm.hasAttr(self.loc, 'tx', checkShape=False))
self.assertTrue(pm.hasAttr(self.loc, 'tx', checkShape=True))
self.assertTrue(self.loc.hasAttr('tx', checkShape=False))
self.assertTrue(self.loc.hasAttr('tx', checkShape=True))
def test_shapeAttr(self):
self.assertFalse(pm.hasAttr(self.loc, 'localPositionX', checkShape=False))
self.assertTrue(pm.hasAttr(self.loc, 'localPositionX', checkShape=True))
self.assertFalse(self.loc.hasAttr('localPositionX', checkShape=False))
self.assertTrue(self.loc.hasAttr('localPositionX', checkShape=True))
def test_badAttr(self):
self.assertFalse(pm.hasAttr(self.loc, 'foobar', checkShape=False))
self.assertFalse(pm.hasAttr(self.loc, 'foobar', checkShape=True))
self.assertFalse(self.loc.hasAttr('foobar', checkShape=False))
self.assertFalse(self.loc.hasAttr('foobar', checkShape=True))
def __getitem__(self, item):
if pm.hasAttr(self._node, item):
return self._node.getAttr(item)
return None
