def push_controlResizeObj(target=None):
_str_func = "push_controlResizeObj"
if target is None:
_sel = mc.ls(sl=True)
if _sel:
_res = []
for t in _sel:
_res.append(push_controlResizeObj(t))
mc.select(_res)
return _res
if not target:
raise ValueError, "|{0}| >> Must have a target".format(_str_func)
if ATTR.has_attr(target, 'cgmControlResizerSource'):
source = ATTR.get_message(target, 'cgmControlResizerSource')
if not source:
raise ValueError, "|{0}| >> no cgmControlResizerSource data on target: {1}".format(
_str_func, target)
source = source[0]
shapeParent_in_place(source,
target,
keepSource=False,
replaceShapes=True)
if ATTR.has_attr(source, 'cgmControlResizer'):
ATTR.delete(source, 'cgmControlResizer')
ATTR.set(source, 'template', 0)
mc.select(source)
return source
else:
raise ValueError, "|{0}| >> no cgmControlResizerSource attr on target: {1}".format(
_str_func, target)
def __setattr2__(self, attr, value, force=True, **kws):
err = None
if not ATTR.has_attr(self.mNode, attr):
log.debug("|{0}| >> trying shape | {1}".format(_str_func,attr))
try:
if ATTR.has_attr(self.mShape.mNode,attr):
log.debug("|{0}| >> trying shape | {1}".format(_str_func,attr))
return r9Meta.MetaClass.__getattribute__(self.mShape,attr, value, force=True, **kws)
except Exception,err:
log.debug("|{0}| >> shape attempt err: {1}".format(_str_func,err))
def test_b_masterNull(self):
mPuppet = self.mi_puppet
mMasterNull = mPuppet.masterNull
self.assertEqual(mPuppet.masterNull.puppet.mNode, mPuppet.mNode,
'mNode walk...')
self.assertEqual(mPuppet.masterNull.puppet, mPuppet, 'meta walk...')
masterDefaultValues = {
'cgmType': ['string', 'ignore'],
'cgmModuleType': ['string', 'master']
}
for attr in masterDefaultValues.keys():
try:
self.assertEqual(ATTR.has_attr(mMasterNull.mNode, attr), True,
attr)
self.assertEqual(ATTR.get_type(mMasterNull.mNode, attr),
masterDefaultValues.get(attr)[0])
self.assertEqual(ATTR.get(mMasterNull.mNode, attr),
masterDefaultValues.get(attr)
[1]) #"{0} value test fail".format(attr)
except Exception, err:
print "{0} attr failed...".format(attr)
for arg in err:
log.error(arg)
raise Exception, err
def reset_channels(nodes=None,selectedChannels=False, transformsOnly=False, excludeChannels=None, keyableOnly=False):
'''
Modified from Morgan Loomis' great reset call to expand options...
'''
gChannelBoxName = mel.eval('$temp=$gChannelBoxName')
_reset = {}
if not nodes:
nodes = mc.ls(sl=True)
if not nodes:
return
if excludeChannels:
if not isinstance(excludeChannels, (list, tuple)):
excludeChannels = [excludeChannels]
chans = None
if selectedChannels:
chans = mc.channelBox(gChannelBoxName, query=True, sma=True)
l_trans = ['translateX','translateY','translateZ','rotateX','rotateY','rotateZ','scaleX','scaleY','scaleZ','tx','ty','yz','rx','ry','rz','sx','sy','sz']
for obj in nodes:
#mObj = r9Meta.MetaClass(obj)
attrs = chans
if not chans:
attrs = mc.listAttr(obj, keyable=True, unlocked=True)
if excludeChannels:
attrs = [x for x in attrs if x not in excludeChannels]
if transformsOnly:
attrs = [x for x in attrs if x in l_trans]
if keyableOnly:
attrs = [x for x in attrs if ATTR.is_keyable(obj,x)]
d_defaults = {}
for plug in ['defaultValues','transResets']:
if ATTR.has_attr(obj, plug):
d_defaults = getattr(r9Meta.MetaClass(obj),plug)
if not attrs:
log.warning("{0} resetAttrs | no attributes offered!".format(obj))
continue
for a in attrs:
try:
if transformsOnly is not None and transformsOnly:
if ATTR.get_nameLong(obj,a) not in l_trans:
continue
dVal = d_defaults.get(a)
if dVal is not None:
default = dVal
else:
default = mc.attributeQuery(a, listDefault=True, node=obj)[0]
ATTR.set(obj,a,default)
_reset[a] = default
except Exception,err:
log.error("{0}.{1} resetAttrs | error: {2}".format(obj, a,err))
class Test_cgmPuppet(unittest.TestCase):
def setUp(self):
try:
self.mi_puppet = PUPPETMETA.cgmPuppet(
'cgmPuppetTesting_puppetNetwork')
except:
self.mi_puppet = cgmMeta.createMetaNode('cgmPuppet',
name='cgmPuppetTesting')
def test_a_network(self):
mPuppet = self.mi_puppet
self.assertEqual(issubclass(type(mPuppet), PUPPETMETA.cgmPuppet), True)
try:
mPuppet._UTILS
except Exception, error:
raise Exception, "No _Utils found | error: {0}".format(error)
self.assertEqual(mc.nodeType(mPuppet.mNode), 'network')
#Attrs -----------------------------------------------------------------------------------------
puppetDefaultValues = {
'cgmName': ['string', 'cgmPuppetTesting'],
'cgmType': ['string', 'puppetNetwork'],
'mClass': ['string', 'cgmPuppet'],
'version': ['double', 1.0],
'masterNull': ['message', [u'cgmPuppetTesting']],
'font': ['string', 'Arial'],
'axisAim': ['enum', 2],
'axisUp': ['enum', 1],
'axisOut': ['enum', 0]
}
for attr in puppetDefaultValues.keys():
try:
self.assertEqual(ATTR.has_attr(mPuppet.mNode, attr), True,
attr)
self.assertEqual(ATTR.get_type(mPuppet.mNode, attr),
puppetDefaultValues.get(attr)[0])
self.assertEqual(ATTR.get(mPuppet.mNode, attr),
puppetDefaultValues.get(attr)
[1]) #"{0} value test fail".format(attr)
except Exception, err:
print "{0} attr failed...".format(attr)
for arg in err:
log.error(arg)
raise Exception, err
def uiFunc_updateFields(self):
_str_func = 'uiFunc_updateFields'
#_type = VALID.get_mayaType(_short)
if not self._mTransformTarget:
return False
_short = self._mTransformTarget.mNode
#_space = self.var_sourceTransSpaceMode.value
#log.info("|{0}| >> Getting data. Space: {1} ".format(_str_func, _space))
#_pos = POS.get(_short,'rp',_space)
_info = POS.get_info(_short)
pprint.pprint(_info)
#pprint.pprint(self._d_transformAttrFields)
_d_sectionToDatKey = {'rotate': 'rotateLocal', 'orient': 'rotation'}
for section in self._d_transformAttrFields.keys():
log.info("|{0}| >> On {1}".format(_str_func, section))
_s = section
if _s in [
'translate', 'rotate', 'position', 'rotateAxis', 'scalePivot',
'orient'
]:
_k = _d_sectionToDatKey.get(_s, _s)
for i, v in enumerate(_info[_k]):
self._d_transformAttrFields[_s]['XYZ'[i]].setValue(v)
elif _s == 'jointOrient':
if ATTR.has_attr(_short, 'jointOrient'):
self._d_transformRows[_s](edit=True, vis=True)
_v = ATTR.get(_short, 'jointOrient')
log.info("|{0}| >> jointOrient: {1}".format(_str_func, _v))
for i, v in enumerate(_v):
self._d_transformAttrFields[_s]['XYZ'[i]].setValue(v)
else:
self._d_transformRows[_s](edit=True, vis=False)
elif _s == 'scale':
for i, v in enumerate(ATTR.get(_short, 'scale')):
self._d_transformAttrFields[_s]['XYZ'[i]].setValue(v)
elif _s == 'scaleLossy':
for i, v in enumerate(TRANS.scaleLossy_get(_short)):
self._d_transformAttrFields[_s]['XYZ'[i]].setValue(v)
else:
log.info("|{0}| >> Missing query for {1}".format(
_str_func, section))
def is_mirrorable(obj=None):
"""
Return if an object is tagged for mirrorable
:returns
status(bool)
"""
_str_func = 'is_mirrorable'
obj = valid_arg_single(obj, 'obj', _str_func)
l_ = ['mirrorSide', 'mirrorIndex', 'mirrorAxis']
for a in l_:
if not ATTR.has_attr(obj, a):
log.debug("|{0}| lacks attr: {1}".format(_str_func, a))
return False
return True
def aim_atPoint(obj = None, position = [0,0,0], aimAxis = "z+", upAxis = "y+", mode = 'local',vectorUp = None,ignoreAimAttrs = False):
"""
Aim functionality.
:parameters:
obj(str): Object to modify
position(array): object to copy from
aimAxis(str): axis that is pointing forward
upAxis(str): axis that is pointing up
mode(str):
'local'-- use standard maya aiming with local axis
'world' -- use standard maya aiming with world axis
'matrix' -- use Bokser's fancy method
'vector' -- maya standard with vector up axis
'object' -- maya standard with object
:returns
success(bool)
"""
try:
_str_func = 'aimAtPoint'
_loc = False
_obj = VALID.objString(obj, noneValid=False, calledFrom = __name__ + _str_func + ">> validate obj")
try:position = position.x,position.y,position.z
except:pass
try:vectorUp = vectorUp.x,vectorUp.y,vectorUp.z
except:pass
log.debug("|{0}| >> obj: {1} | position:{2} | mode: {3}".format(_str_func,_obj,position,mode))
if not ignoreAimAttrs:
_d_aim = ATTR.validate_arg(_obj,'axisAim')
_d_up =ATTR.validate_arg(_obj,'axisUp')
if ATTR.has_attr(_d_aim) and ATTR.has_attr(_d_up):
aimAxis = ATTR.get_enumValueString(_d_aim)
upAxis = ATTR.get_enumValueString(_d_up)
log.debug("|{0}| >> obj: {1} aimable from attrs. aim: {2} | up: {3}".format(_str_func,_obj,aimAxis,upAxis))
if mode == 'matrix':
'''Rotate transform based on look vector'''
# get source and target vectors
objPos = POS.get(_obj, asEuclid=True)
targetPos = MATH.Vector3.Create(position)
aim = (targetPos - objPos).normalized()
if not vectorUp:
upVector = MATH.Vector3.up()
if upAxis == "y-":
upVector = MATH.Vector3.down()
elif upAxis == "z+":
upVector = MATH.Vector3.forward()
elif upAxis == "z-":
upVector = MATH.Vector3.back()
elif upAxis == "x+":
upVector = MATH.Vector3.right()
elif upAxis == "x-":
upVector = MATH.Vector3.left()
else:
upVector = MATH.Vector3.up()
vectorUp = MATH.transform_direction( _obj, upVector )
wantedAim, wantedUp = MATH.convert_aim_vectors_to_different_axis(aim, vectorUp, aimAxis, upAxis)
xformPos = mc.xform(_obj, q=True, matrix = True, ws=True)
pos = MATH.Vector3(xformPos[12], xformPos[13], xformPos[14])
rot_matrix = EUCLID.Matrix4.new_look_at(MATH.Vector3.zero(), -wantedAim, wantedUp)
s = MATH.Vector3.Create( mc.xform(_obj, q=True, ws=True, s=True) )
scale_matrix = EUCLID.Matrix4()
scale_matrix.a = s.x
scale_matrix.f = s.y
scale_matrix.k = s.z
scale_matrix.p = 1
result_matrix = rot_matrix * scale_matrix
transform_matrix = result_matrix[0:12] + [pos.x, pos.y, pos.z, 1.0]
mc.xform(_obj, matrix = transform_matrix , roo="xyz", ws=True)
"""elif mode == 'world':
_loc = mc.spaceLocator()[0]
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
_constraint = mc.aimConstraint(_loc,_obj,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
mc.delete(_constraint + [_loc])"""
elif mode in ['local','world','vector','object']:
_loc = mc.spaceLocator(name='test')[0]
_loc_snap = POS.create_loc(_obj)
mc.move (position[0],position[1],position[2], _loc, ws=True)
mAxis_aim = VALID.simpleAxis(aimAxis)
mAxis_up = VALID.simpleAxis(upAxis)
if mode == 'world':
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'scene',)
elif mode == 'object':
vectorUp = VALID.mNodeString(vectorUp)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'object',
worldUpObject = vectorUp)
#worldUpVector = _vUp)
else:
if mode == 'vector':
_vUp = vectorUp
else:
_vUp = MATH.get_obj_vector(_obj,upAxis)
_constraint = mc.aimConstraint(_loc,_loc_snap,
maintainOffset = False,
aimVector = mAxis_aim.p_vector,
upVector = mAxis_up.p_vector,
worldUpType = 'vector',
worldUpVector = _vUp)
go(obj,_loc_snap)
mc.delete(_constraint,_loc_snap)
else:
raise NotImplementedError,"mode: {0}".format(mode)
if _loc:mc.delete(_loc)
return True
except Exception,err:
try:mc.delete(_loc)
except:pass
log.error( "aim_atPoint | obj: {0} | err: {1}".format(obj,err) )
except Exception,err:
log.error("|{0}| >> Failed to get key data. Section: {0} | key: {1}...".format(_str_func,_s,key))
log.error(err)
#log.warning("|{0}| >> Haven't setup for {1}...".format(_str_func,_s))
#if _s in ['translate','rotate','scale','jointOrient','rotateAxis']:
#pprint.pprint(_d_fieldValues)
if _s in ['translate','rotate','scale','jointOrient','rotateAxis']:
for a,v in _d_fieldValues.iteritems():
_a = _s + a
log.info("|{0}| >> Trying attr: {1} | v: {2}... ".format(_str_func,_a,v))
for mObj in _ml_targets:
if not ATTR.has_attr(mObj.mNode,_s):
log.info("|{0}| >> Object lacks {2} attr : {1}... ".format(_str_func,mObj.mNode,_s))
return
log.info("|{0}| >> Trying Object: {1}... ".format(_str_func,mObj.mNode))
try:ATTR.set(mObj.mNode,_a,v)
except Exception,err:
log.error("|{0}| >> Failed to get set data. Object: {0} | a: {1} | v: {2}...".format(_str_func,mObj.mNode,_a,v))
log.error(err)
elif _s == 'position':
for mObj in _ml_targets:
log.info("|{0}| >> Trying Object: {1} | [{2}]... ".format(_str_func,mObj.mNode,_s))
pos = TRANS.position_get(mObj.mNode)
log.info("|{0}| >> pre pos: [{1}] ".format(_str_func,pos))
for k,v in _d_fieldValues.iteritems():
pos['XYZ'.index(k)] = v
def override_color(target=None,
key=None,
index=None,
rgb=None,
pushToShapes=True):
"""
Sets the color of a shape or object via override. In Maya 2016, they introduced
rgb value override.
:parameters
target(str): What to color - shape or transform with shapes
key(varied): if str will check against our shared color dict definitions for rgb and index entries
index(int): Color index
rgb(list): rgb values to set in Maya 2016 or above
pushToShapes(bool): Push the overrides to shapes of passed transforms
:returns
info(dict)
"""
_str_func = "set_color"
if not target:
raise ValueError, "|{0}| >> Must have a target".format(_str_func)
l_targets = VALID.listArg(target)
for t in l_targets:
_shapes = []
#If it's accepable target to color
#mTarget = r9Meta.MetaClass(target, autoFill=False)
if ATTR.has_attr(t, 'overrideEnabled'):
log.debug(
"|{0}| >> overrideEnabled on target...".format(_str_func))
_shapes.append(t)
if pushToShapes:
_bfr = mc.listRelatives(t, s=True, fullPath=True)
if _bfr:
_shapes.extend(_bfr)
if not _shapes:
raise ValueError, "|{0}| >> Not a shape and has no shapes: '{1}'".format(
_str_func, t)
#log.debug(key)
#log.debug(index)
#log.debug(rgb)
if index is None and rgb is None and key is None:
raise ValueError, "|{0}| >> Must have a value for index,rgb or key".format(
_str_func)
#...little dummy proofing..
if key:
_type = type(key)
if _type not in [str, unicode]:
log.debug(
"|{0}| >> Not a string arg for key...".format(_str_func))
if rgb is None and issubclass(_type, list) or issubclass(
_type, tuple):
log.debug(
"|{0}| >> vector arg for key...".format(_str_func))
rgb = key
key = None
elif index is None and issubclass(_type, int):
log.debug("|{0}| >> int arg for key...".format(_str_func))
index = key
key = None
else:
raise ValueError, "|{0}| >> Not sure what to do with this key arg: {1}".format(
_str_func, key)
_b_RBGMode = False
_b_2016Plus = False
if cgmGEN.__mayaVersion__ >= 2016:
_b_2016Plus = True
if key is not None:
_color = False
if _b_2016Plus:
log.debug("|{0}| >> 2016+ ...".format(_str_func))
_color = SHARED._d_colors_to_RGB.get(key, False)
if _color:
rgb = _color
if _color is False:
log.debug(
"|{0}| >> Color key not found in rgb dict checking index..."
.format(_str_func))
_color = SHARED._d_colors_to_index.get(key, False)
if _color is False:
raise ValueError, "|{0}| >> Unknown color key: '{1}'".format(
_str_func, key)
if rgb is not None:
if not _b_2016Plus:
raise ValueError, "|{0}| >> RGB values introduced in maya 2016. Current version: {1}".format(
_str_func, cgmGEN.__mayaVersion__)
_b_RBGMode = True
if len(rgb) == 3:
_color = rgb
else:
raise ValueError, "|{0}| >> Too many rgb values: '{1}'".format(
_str_func, rgb)
if index is not None:
_color = index
log.debug("|{0}| >> Color: {1} | rgbMode: {2}".format(
_str_func, _color, _b_RBGMode))
for i, s in enumerate(_shapes):
mShape = r9Meta.MetaClass(s)
mShape.overrideEnabled = True
#attributes.doSetAttr(s,'overrideEnabled',True)
if _b_RBGMode:
mShape.overrideRGBColors = 1
mShape.overrideColorRGB = _color
#attributes.doSetAttr(s,'overrideRGBColors','RGB')#...brilliant attr naming here Autodesk...
#attributes.doSetAttr(s,'overrideColorsRGB',[1,1,1])
else:
if _b_2016Plus:
mShape.overrideRGBColors = 0
mShape.overrideColor = _color
def create_axisProxy(obj=None):
"""
Make a local axis box around a given object so that you can then
"""
try:
_str_func = 'create_axisProxy'
_dag = VALID.getTransform(obj)
if not _dag:
raise ValueError, "Must have a dag node. Obj: {0}".format(obj)
if VALID.is_shape(obj):
l_shapes = [obj]
else:
l_shapes = TRANS.shapes_get(_dag, True)
_parent = TRANS.parent_get(_dag)
_dup = mc.duplicate(l_shapes, po=False, rc=True)[0]
#TRANS.pivots_recenter(_dup)
_dup = TRANS.parent_set(_dup, False)
ATTR.set_standardFlags(_dup, lock=False, keyable=True)
#Get some values...
l_reset = ['t', 'r', 's', 'shear', 'rotateAxis']
t = ATTR.get(_dup, 'translate')
r = ATTR.get(_dup, 'rotate')
s = ATTR.get(_dup, 'scale')
ra = ATTR.get(_dup, 'rotateAxis')
if ATTR.has_attr(_dup, 'jointOrient'):
l_reset.append('jointOrient')
jo = ATTR.get(_dup, 'jointOrient')
o = TRANS.orient_get(_dup)
shear = ATTR.get(_dup, 'shear')
_scaleLossy = TRANS.scaleLossy_get(_dag)
#Reset our stuff before we make our bb...
ATTR.reset(_dup, l_reset)
_size = POS.get_bb_size(_dup, True)
#_proxy = create_proxyGeo('cube',COREMATH.list_div(_scaleLossy,_size))
_proxy = create_proxyGeo('cube', _size)
mc.makeIdentity(_proxy, apply=True, scale=True)
#Now Put it back
_dup = TRANS.parent_set(_dup, TRANS.parent_get(_dag))
_proxy = TRANS.parent_set(_proxy, _dup)
#_dup = TRANS.parent_set(_dup, TRANS.parents_get(_dag))
SNAP.go(_dup, _dag)
#ATTR.set(_dup,'s',(0,0,0))
ATTR.reset(_dup, ['s', 'shear'])
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
_proxy = TRANS.parent_set(_proxy, _dag)
ATTR.reset(_proxy, ['t', 'r', 's', 'shear', 'rotateAxis'])
#match_transform(_proxy,_dag)
#SNAP.go(_proxy,_dag,pivot='bb')
#cgmGEN.func_snapShot(vars())
_proxy = TRANS.parent_set(_proxy, False)
mc.delete(_dup)
#match_transform(_proxy,_dag)
return mc.rename(_proxy,
"{0}_localAxisProxy".format(NAMES.get_base(_dag)))
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, msg=vars())
