def mirror_controlShape(source=None,
target=None,
colorDirection='right',
controlType='main'):
_str_func = "mirror_controlShape"
if target is None:
_sel = mc.ls(sl=True)
if len(_sel) == 2:
return mirror_controlShape(_sel[0], _sel[1])
if not source:
raise ValueError, "|{0}| >> Must have a source".format(_str_func)
if not target:
raise ValueError, "|{0}| >> Must have a target".format(_str_func)
_dup_curve = mc.duplicate(source)[0]
for child in TRANS.children_get(_dup_curve, True):
mc.delete(child)
ATTR.set_standardFlags(_dup_curve, lock=False, keyable=True, visible=True)
_grp = mc.group(em=True)
_dup_curve = TRANS.parent_set(_dup_curve, _grp)
ATTR.set(_grp, 'scaleX', -1)
_dup_curve = TRANS.parent_set(_dup_curve, False)
mc.makeIdentity(_dup_curve,
apply=True,
translate=True,
rotate=True,
scale=False)
return
shapeParent_in_place(target, _dup_curve, True, True)
mc.delete(_grp)
colorControl(target, colorDirection, controlType)
mc.select(target)
return target
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 get_lights(self):
_str_func = 'factory.get_lights'
_profile = d_profiles.get(self.profile)
self.ml_lights = []
self.ml_lightDags = []
for n,d in _profile.iteritems():
_type = d.get('type')
try:_light = d_lightCalls[_type]()
except:
log.error("|{0}| >> Light create fail {1} | {2}".format(_str_func,n,_type))
continue
mLight = cgmMeta.asMeta(_light)
mLight.addAttr('cgmType','cgmLight',lock=True)
mDag = mLight.getTransform(asMeta=True)
mDag.rename("{0}_cgmLight".format(n))
for a,v in d['settings'].iteritems():
log.debug("|{0}| >> setting {1} | {2}:{3}".format(_str_func,n,a,v))
ATTR.set(mLight.mNode,a,v)
mDag.p_position = d['dag']['position']
mDag.p_orient = d['dag']['orient']
log.debug("|{0}| >> setting {1} | position:{2}".format(_str_func,n,d['dag']['position']))
log.debug("|{0}| >> setting {1} | orient:{2}".format(_str_func,n,d['dag']['orient']))
self.ml_lightDags.append(mDag)
self.ml_lights.append(mLight)
def set_attrs(self,
attr=None,
value=None,
context='selection',
mType=None,
select=True):
"""
Get data for updating a transform
:parameters
self(instance): cgmMarkingMenu
:returns
info(dict)
"""
_str_func = "set_attr"
_context = context.lower()
_sl = mc.ls(sl=True)
_l_context = get_list(_context, mType)
log.debug(
"|{0}| >> attr: {1} | value: {2} | mType: {3} | context: {4}".format(
_str_func, attr, value, mType, _context))
for o in _l_context:
try:
#log.debug("|{0}| >> obj:{1} | attr:{2} | value:{3} ".format(_str_func,o,attr,value))
ATTR.set(o, attr, value)
#cgmMeta.cgmNode(o).__setattr__(attr,value)
except Exception, err:
log.error(
"|{0}| >> set fail. obj:{1} | attr:{2} | value:{3} | error: {4} | {5}"
.format(_str_func, NAMES.get_short(o), attr, value, err,
Exception))
def get_uv_normal(mesh, uvValue, asEuclid=False):
"""
Get a normal at a uv
:parameters:
mesh(string) | Surface uv resides on
uValue(float) | uValue
vValue(float) | vValue
asEuclid(bool) - whether to return as Vector or not
:returns
pos(double3)
"""
_str_func = 'get_uv_position'
_follicle = NODE.add_follicle(mesh)
ATTR.set(_follicle[0], 'parameterU', uvValue[0])
ATTR.set(_follicle[0], 'parameterV', uvValue[1])
_normal = ATTR.get(_follicle[0], 'outNormal')
mc.delete(_follicle)
if asEuclid:
log.debug("|{0}| >> asEuclid...".format(_str_func))
return EUCLID.Vector3(_normal[0], _normal[1], _normal[2])
return _normal
def uiFunc_valuesTweak(self, mode='+'):
_str_func = 'uiFunc_valuesTweak'
if mode == 'zero':
log.info("|{0}| >> Zeroing ".format(_str_func))
for a in 'XYZ':
self.__dict__['uiff_transformTweak{0}'.format(a)].setValue(0)
for k, cb in self._d_transformCBs.iteritems():
cb.setValue(0)
return
_ml_targets = uiFunc_getTargets(self)
if not _ml_targets:
raise ValueError, "Must have targets"
_l_toTweak = []
for k, cb in self._d_transformCBs.iteritems():
if cb.getValue():
_l_toTweak.append(k)
_tweak = []
for a in 'XYZ':
_tweak.append(
self.__dict__['uiff_transformTweak{0}'.format(a)].getValue())
pprint.pprint([mode, _l_toTweak, _tweak])
if mode == '+':
_tweak_call = MATH.list_add
else:
_tweak_call = MATH.list_subtract
for mObj in _ml_targets:
for attr in _l_toTweak:
if attr in [
'translate', 'rotate', 'scale', 'jointOrient', 'rotateAxis'
]:
_v = ATTR.get(mObj.mNode, attr)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
ATTR.set(mObj.mNode, attr, _v)
elif attr == 'position':
_v = TRANS.position_get(mObj.mNode)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
TRANS.position_set(mObj.mNode, _v)
elif attr == 'orient':
_v = TRANS.orient_get(mObj.mNode)
log.info("|{0}| >> pre tweak: [{1}] ".format(_str_func, _v))
_v = _tweak_call(_v, _tweak)
log.info("|{0}| >> post tweak: [{1}] ".format(_str_func, _v))
TRANS.orient_set(mObj.mNode, _v)
else:
log.warning("|{0}| >> Haven't setup for {1}...".format(
_str_func, _s))
pass
def get_uv_position(mesh, uvValue, asEuclid=False):
"""
Get a uv position in world space. UV should be normalized.
:parameters:
mesh(string) | Surface uv resides on
uValue(float) | uValue
vValue(float) | vValue
asEuclid(bool) - whether to return as Vector or not
:returns
pos(double3)
"""
_str_func = 'get_uv_position'
_follicle = NODE.add_follicle(mesh)
ATTR.set(_follicle[0], 'parameterU', uvValue[0])
ATTR.set(_follicle[0], 'parameterV', uvValue[1])
_pos = get(_follicle[1])
mc.delete(_follicle)
if asEuclid:
log.debug("|{0}| >> asEuclid...".format(_str_func))
return EUCLID.Vector3(_pos[0], _pos[1], _pos[2])
return _pos
def profile_load(target = None, arg = None, module = dynFKPresets, clean = True):
_str_func = 'profile_apply'
mTar = cgmMeta.asMeta(target, noneValid = True)
if not mTar:
return log.error(cgmGEN.logString_msg(_str_func, "No valid target"))
_type = mTar.getMayaType()
_key = d_shortHand.get(_type,_type)
log.info(cgmGEN.logString_msg(_str_func,"mTar: {0} | {1}".format(_type, mTar)))
_d_profile = profile_get(arg,module)
if not _d_profile:
log.warning("Invalid profile: {0}".format(arg))
return False
_d_type = _d_profile.get(_key)
if not _d_type:
log.warning("No {0} dat".format(_type))
return False
if clean:
d_use = profile_get('base',module).get(_key)
d_use.update(_d_type)
else:
d_use = _d_type
_node = mTar.mNode
for a,v in d_use.iteritems():
log.debug("{0} || {1} | {2}".format(_type, a,v))
try:
ATTR.set(_node, a, v)
#mNucleus.__setattr__(a,v)
except Exception,err:
log.warning("{3} | Failed to set: {0} | {1} | {2}".format(a,v,err, _type))
def release_post_insert(self):
_str_funcName = 'follicleAttach.release'
"""if not self.b_dragStoreMode:#If not on drag, do it here. Otherwise do it on update
if self._posBuffer:
self.l_return.extend(self._posBuffer)
if self._posBufferRaw:
self.l_returnRaw.extend(self._posBufferRaw)
else:
self.l_returnRaw.extend(self._posBuffer)
if self._createModeBuffer:
self.l_created.extend(self._createModeBuffer)"""
for pos in self.l_returnRaw:
log.debug("|{0}|...pos {1}".format(_str_funcName,pos))
for i,m in enumerate(self.d_meshPos.keys()):
log.debug("|{0}|...mesh: {1}".format(_str_funcName,m))
for i2,h in enumerate(self.d_meshPos[m]):
if h == pos:
log.debug("Found follicle match!")
try:
_set = [m, self.d_meshUV[m][i2], "{0}_u{1}_v{2}".format(coreNames.get_short(m),"{0:.4f}".format(self.d_meshUV[m][i2][0]),"{0:.4f}".format(self.d_meshUV[m][i2][1]))]
self._l_folliclesToMake.append(_set)
log.debug("|{0}|...uv {1}".format(_str_funcName,_set))
except Exception,err:
log.error("|{0}| >> Failed to query uv for hit {2} on shape {2} | err:{1}".format(_str_funcName,err,pos,m))
if self._l_folliclesToMake:
for f_dat in self._l_folliclesToMake:
_follicle = NODES.add_follicle(f_dat[0],f_dat[2])
log.info("|finalize| >> Follicle created: {0}".format(_follicle))
ATTR.set(_follicle[0],'parameterU',f_dat[1][0])
ATTR.set(_follicle[0],'parameterV',f_dat[1][1])
mc.parent(_loc, _follicle[0])
def create_controlResizeObj(target=None):
_str_func = "create_controlResizeObj"
if target is None:
_sel = mc.ls(sl=True)
if _sel:
_res = []
for t in _sel:
_res.append(create_controlResizeObj(t))
return _res
if not target:
raise ValueError, "|{0}| >> Must have a target".format(_str_func)
if ATTR.get_message(target, 'cgmControlResizer'):
return ATTR.get_message(target, 'cgmControlResizer')
handle = create_at(target, 'null')
ATTR.set_message(target, 'cgmControlResizer', handle)
ATTR.set_message(handle, 'cgmControlResizerSource', target)
handle = mc.rename(handle, NAMES.base(target) + '_cgmResizer')
shapeParent_in_place(handle, target)
ATTR.set(target, 'template', 1)
return handle
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))
def ik_base(self,ikBase = None, ml_baseJoints = None, ml_fkShapes = None):
try:
_str_func = 'segment_handles'
log_start(_str_func)
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
if ikBase == None:
ikBase = mBlock.getEnumValueString('ikBase')
if not ml_baseJoints:
raise ValueError,"{0} | ml_baseJoints required".format(_str_func)
log.debug("|{0}| >> {1} ...".format(_str_func,ikBase))
if ikBase in ['hips','simple']:
if ikBase == 'hips':
mIKBaseCrv = ml_baseJoints[1].doCreateAt(setClass=True)
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType'])
mIKBaseCrv.doStore('cgmName','hips')
else:
mIKBaseCrv = ml_baseJoints[0].doCreateAt(setClass=True)
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType'])
CORERIG.shapeParent_in_place(mIKBaseCrv.mNode, ml_fkShapes[0].mNode, True)
else:
log.debug("|{0}| >> default IK base shape...".format(_str_func))
mIK_formHandle = ml_formHandles[ 0 ]
#bb_ik = mHandleFactory.get_axisBox_size(mIK_formHandle.mNode)
bb_ik = POS.get_bb_size(mIK_formHandle.mNode,True,mode='max')
_ik_shape = CURVES.create_fromName('cube', size = bb_ik)
ATTR.set(_ik_shape,'scale', 1.1)
mIKBaseShape = cgmMeta.validateObjArg(_ik_shape, 'cgmObject',setClass=True)
mIKBaseShape.doSnapTo(mIK_formHandle)
#pos_ik = POS.get_bb_center(mProxyHelper.mNode)
#SNAPCALLS.get_special_pos(mEndHandle.p_nameLong,
# 'axisBox','z+',False)
#mIKBaseShape.p_position = pos_ik
mIKBaseCrv = ml_baseJoints[0].doCreateAt()
mIKBaseCrv.doCopyNameTagsFromObject(ml_baseJoints[0].mNode,ignore=['cgmType'])
CORERIG.shapeParent_in_place(mIKBaseCrv.mNode, mIKBaseShape.mNode, False)
mIKBaseCrv.doStore('cgmTypeModifier','ikBase')
mIKBaseCrv.doName()
self.mHandleFactory.color(mIKBaseCrv.mNode, controlType = 'main')
self.mRigNull.connectChildNode(mIKBaseCrv,'controlIKBase','rigNull')#Connect
except Exception,err:cgmGEN.cgmExceptCB(Exception,err,localDat=vars())
def define(self):
_short = self.mNode
ATTR.set(_short, 'translate', [0, 0, 0])
ATTR.set(_short, 'rotate', [0, 0, 0])
ATTR.set_standardFlags(self.mNode,
attrs=['translate', 'rotate', 'sx', 'sz'])
for a in ['x', 'z']:
ATTR.connect("{0}.sy".format(_short), "{0}.s{1}".format(_short, a))
ATTR.set_alias(_short, 'sy', 'blockScale')
def copy_constraint(sourceConstraint=None,
targetObj=None,
constraintType=None,
maintainOffset=True):
"""
Copy the constraint settings from a constraint to another object
:parameters:
node(str): node to query
:returns
list of constraints(list)
"""
_str_func = 'copy_constraint'
log.debug("|{0}| >> constraint: {1} ".format(_str_func, sourceConstraint))
d_source = get_datDict(sourceConstraint)
_type = d_source['type']
if constraintType is None:
if targetObj is None:
raise ValueError, "|{0}| >> Must have targetObject or constraintType ".format(
_str_func)
else:
log.info(
"|{0}| >> No constraintType passed. Using source's: '{1}' ".
format(_str_func, _type))
constraintType = _type
_call = _d_type_to_call.get(constraintType, False)
if not _call:
raise ValueError, "|{0}| >> {1} not a known type of constraint. node: {2}".format(
_str_func, _type, sourceConstraint)
if targetObj is None:
targetObj = d_source['driven']
log.info(
"|{0}| >> No target object passed. Using source's: '{1}' ".format(
_str_func, targetObj))
cgmGEN.func_snapShot(vars())
result = _call(d_source['targets'],
targetObj,
maintainOffset=maintainOffset)
d_result = get_datDict(result[0])
for i, a in enumerate(d_result['attrs']):
if d_source['attrDrivers'][i]:
ATTR.connect("{0}".format(d_source['attrDrivers'][i]),
"{0}.{1}".format(result[0], d_result['attrs'][i]))
else:
ATTR.set(result[0], d_result['attrs'][i],
d_source['attrWeights'][d_source['attrs'][i]])
return result
def setup_forCapture(state = 1):
mel.eval('PreferencesWindow;')
mel.eval('preferencesWnd "Display";')
if state:
mel.eval('ActivateViewport20;')
else:
mel.eval('setRendererInModelPanel base_OpenGL_Renderer modelPanel4;')
ATTR.set('hardwareRenderingGlobals.lineAAEnable',state)
ATTR.set('hardwareRenderingGlobals.multiSampleEnable',state)
if state:
mel.eval('updateLineWidth 2;')
else:
mel.eval('updateLineWidth 1;')
def scale_to_axisSize(arg=None, size=None):
_str_func = 'scale_to_axisSize'
log.debug(cgmGEN.logString_start(_str_func))
_currentSize = get_axisSize(arg)
_currentScale = ATTR.get(arg, 'scale')
_targetScale = []
for i, s in enumerate(size):
if s is not None:
v = (_currentScale[i] * s) / _currentSize[i]
_targetScale.append(v)
else:
_targetScale.append(_currentScale[i])
#log.info(_targetScale)
for i, a in enumerate('xyz'):
if size[i]:
ATTR.set(arg, 's{0}'.format(a), _targetScale[i])
def verify_aimAttrs(obj=None, aim=None, up=None, checkOnly=False):
"""
Make sure an object has aim attributes.
:parameters:
obj(str): Object to modify
aim(arg): Value to set with on call
up(arg): Value to set with on call
out(arg): Value to set with on call
checkOnly(bool): Check only, no adding attrs
:returns
success(bool)
"""
_str_func = 'verify_aimAttrs'
_str_enum = 'x+:y+:z+:x-:y-:z-'
_obj = VALID.objString(obj,
noneValid=False,
calledFrom=__name__ + _str_func + ">> validate obj")
_l = [aim, up]
_l_defaults = [aim or 2, up or 1]
for i, a in enumerate(['axisAim', 'axisUp']):
_d = ATTR.validate_arg(_obj, a)
_good = False
if mc.objExists(_d['combined']):
if ATTR.get_type(_d) == 'enum':
if ATTR.get_enum(_d) == _str_enum:
_good = True
if not _good:
if checkOnly:
return False
log.debug("|{0}| >> {1} not a good attr. Must rebuild".format(
_str_func, _d['combined']))
ATTR.delete(_d)
ATTR.add(_d, 'enum', enumOptions=_str_enum, hidden=False)
ATTR.set(_d, value=_l_defaults[i])
ATTR.set_keyable(_d, False)
_v = _l[i]
if _v is not None:
ATTR.set(_d, value=_v)
return True
def radius_modify(self, mode='+', factor=10):
_str_func = 'radius_modify'
_sel = MMCONTEXT.get_list(self.var_contextTD.value, 'joint')
if not _sel:
return log.error("|{0}| >> Nothing selected".format(_str_func))
for j in _sel:
_r = ATTR.get(j, 'radius')
if mode == '+':
_r = _r + factor
elif mode == '-':
_r = _r - factor
elif mode == '*':
_r = _r * factor
elif mode == '/':
_r = _r / factor
ATTR.set(j, 'radius', _r)
def shaderDat_set(dat={}, key=None, nodes=[]):
_d = dat.get(key, False)
if not _d:
return False
if not nodes:
nodes = mc.ls(sl=1)
_res = {}
mNodes = cgmMeta.asMeta(nodes)
for node in nodes:
for a, v in _d.iteritems():
if a in ['color']:
continue
log.info(node)
try:
log.info('{0} --> {1}'.format(a, v))
ATTR.set(node, a, v)
except Exception, err:
log.error("{0} | {1}".format(node, err))
def modules_settings_set(self, **kws):
try:
_str_func = ' modules_settings_set'.format(self)
log.debug("|{0}| >> ... [{1}]".format(_str_func, self) + '-' * 80)
for mModule in modules_get(self):
if mModule.rigNull.getMessage('settings'):
mSettings = mModule.rigNull.settings
_short_settings = mSettings.mNode
for k, v in kws.iteritems():
try:
ATTR.set(_short_settings, k, v)
except Exception, err:
#if mSettings.hasAttr(k):
log.debug(
"|{0}| >> Failed to set: mModule:{1} | k:{2} | v:{3} | {4}"
.format(_str_func, mModule.mNode, k, v, err))
else:
log.debug("|{0}| >> Missing settings: {1}".format(
_str_func, mModule))
return True
def scaleLocal_set(node=None, new_scale = [1,1,1]):
"""
Set the local scale of a given obj
:parameters:
node(str): node to query
new_scale(double3): Value to set. May be Euclid.Vector3
:returns
rotation(vector/asEuclid.Vector3)
"""
_str_func = 'scaleLocal_set'
_node = VALID.mNodeString(node)
try:new_scale = VALID.euclidVector3List(new_scale)
except:pass
log.debug("|{0}| >> [{2}] = {1}".format(_str_func,new_scale,_node))
ATTR.set(_node,'scale',new_scale)
def rotate_set(node=None, new_rot = None):
"""
Set the local rotation/euler of a given obj
:parameters:
node(str): node to query
new_rot(double3): Value to set. May be Euclid.Vector3
:returns
rotation(vector/asEuclid.Vector3)
"""
_str_func = 'rotate_set'
_node = VALID.mNodeString(node)
try:new_rot = VALID.euclidVector3List(new_rot)
except:pass
log.debug("|{0}| >> [{2}] = {1}".format(_str_func,new_rot,_node))
ATTR.set(_node,'rotate',new_rot)
def set_weightsByDistance(constraint=None, vList=None):
"""
:parameters:
node(str): node to query
:returns
list of constraints(list)
"""
_str_func = 'set_weightsByDistance'
log.debug("|{0}| >> constraint: {1} ".format(_str_func, constraint))
#if vList:
#raise NotImplementedError,'Not yet'
_attrs = get_targetWeightsAttrs(constraint)
if not vList:
pos_obj = TRANS.position_get(get_driven(constraint))
targets = get_targets(constraint)
_l_dist = []
for t in targets:
_l_dist.append(
DIST.get_distance_between_points(pos_obj,
TRANS.position_get(t)))
vList = MATH.normalizeList(_l_dist)
log.debug("|{0}| >> targets: {1} ".format(_str_func, targets))
log.debug("|{0}| >> raw: {1} ".format(_str_func, _l_dist))
log.debug("|{0}| >> normalize: {1} ".format(_str_func, vList))
log.debug("|{0}| >> attrs: {1} ".format(_str_func, _attrs))
if len(_attrs) != len(vList):
raise ValueError, "Len of attrs and valueList do not match: {0} | {1}".format(
len(_attrs), len(vList))
for i, v in enumerate(vList):
ATTR.set(constraint, _attrs[i], v)
return vList
def patch_templateToForm():
try:
_str_func = 'patch_templateToForm'
log.debug(cgmGEN.logString_start(_str_func))
_l = mc.ls()
_progressBar = CGMUI.doStartMayaProgressBar(stepMaxValue=len(_l))
for i, o in enumerate(_l):
_str = "{0} | {1} ".format(i, o)
log.debug(cgmGEN.logString_sub(_str_func, _str))
CGMUI.progressBar_set(_progressBar, step=1, status=_str)
mObj = cgmMeta.asMeta(o)
for a in mc.listAttr(o, ud=True) or []:
log.debug(cgmGEN.logString_msg(_str_func, str(a)))
if 'template' in a:
log.info(
cgmGEN.logString_msg(
_str_func,
"{0} | {1} | template in".format(_str, a)))
ATTR.rename(o, a, a.replace('template', 'form'))
elif 'Template' in a:
log.info(
cgmGEN.logString_msg(
_str_func,
"{0} | {1} | Template in".format(_str, a)))
ATTR.rename(o, a, a.replace('Template', 'Form'))
v = ATTR.get(o, a)
if 'template' == str(v):
log.info(
cgmGEN.logString_msg(
_str_func,
"{0} | {1} | template value".format(_str, str(a))))
ATTR.set(o, a, 'form')
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def get_HSV_fromRGB(rValue=0, gValue=0, bValue=0, getNode=False):
_node = mc.createNode('rgbToHsv')
ATTR.set(_node, 'inRgbR', COREMATH.Clamp(float(rValue), 0, 1.0))
ATTR.set(_node, 'inRgbG', COREMATH.Clamp(float(gValue), 0, 1.0))
ATTR.set(_node, 'inRgbB', COREMATH.Clamp(float(bValue), 0, 1.0))
res = ATTR.get(_node, 'outHsv')[0]
if getNode:
return _node, res
mc.delete(_node)
return res
def get_RGB_fromHSV(rValue=0, gValue=0, bValue=0, getNode=False):
_node = mc.createNode('hsvToRgb')
ATTR.set(_node, 'inHsvB', COREMATH.Clamp(float(bValue), 0.0001, 1.0))
ATTR.set(_node, 'inHsvG', COREMATH.Clamp(float(gValue), 0.0001, 1.0))
ATTR.set(_node, 'inHsvR', COREMATH.Clamp(float(rValue), 0.000001, 360.0))
res = ATTR.get(_node, 'outRgb')[0]
if getNode:
return _node, res
mc.delete(_node)
return res
def optimize(nodeTypes='multiplyDivide'):
_str_func = 'optimize'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_nodeTypes = VALID.listArg(nodeTypes)
d_modeToNodes = {}
d_modeToPlugs = {}
l_oldNodes = []
for t in _nodeTypes:
if t in ['plusMinusAverage']:
raise ValueError, "Don't handle type: {0}".format(t)
nodes = mc.ls(type=t)
l_oldNodes.extend(nodes)
for n in nodes:
_mode = ATTR.get(n, 'operation')
_operator = ATTR.get_enumValueString(n, 'operation')
#d_operator_to_NodeType[t][_mode]
if not d_modeToNodes.get(_mode):
d_modeToNodes[_mode] = []
d_modeToNodes[_mode].append(n)
d_plugs = {}
d_plugValues = {}
for i, inPlug in enumerate(d_node_to_input[t]['in']):
d_plugs[i] = ATTR.get_children(n, inPlug) or []
for p in d_plugs[i]:
c = ATTR.get_driver(n, p, False, skipConversionNodes=True)
if c:
d_plugValues[p] = c
else:
d_plugValues[p] = ATTR.get(n, p)
l_outs = ATTR.get_children(n, d_node_to_input[t]['out']) or []
for p in l_outs:
d_plugValues[p] = ATTR.get_driven(n,
p,
False,
skipConversionNodes=True)
#pprint.pprint(d_modeToNodes)
#pprint.pprint(d_plugs)
#print l_outs
#print cgmGeneral._str_subLine
#pprint.pprint(d_plugValues)
for i in range(len(l_outs)):
_out = d_plugValues[l_outs[i]]
if _out:
d_set = {'out': _out, 'in': []}
log.debug("|{0}| >> Output found on: {1} ".format(
_str_func, _out))
_keys = d_plugs.keys()
_keys.sort()
for k in _keys:
d_set['in'].append(d_plugValues[d_plugs[k][i]])
#d_set['in'].append(d_plugs[k][i])
#pprint.pprint(d_set)
if not d_modeToPlugs.get(_mode):
d_modeToPlugs[_mode] = []
d_modeToPlugs[_mode].append(d_set)
# if VALID.stringArg()
l_inPlugs = ['input1', 'input2']
l_outplugs = [u'output']
l_new = []
_cnt = 0
for operator, d_sets in d_modeToPlugs.iteritems():
if operator == 1:
for nodeSet in d_sets:
newNode = mc.createNode('multDoubleLinear')
newNode = mc.rename(newNode,
'optimize_{0}_mdNode'.format(_cnt))
_cnt += 1
l_new.append(newNode)
_ins = d_set['in']
_outs = d_set['out']
for iii, inPlug in enumerate(_ins):
if mc.objExists(inPlug):
ATTR.connect(inPlug,
"{0}.{1}".format(newNode, l_inPlugs[iii]))
else:
ATTR.set(newNode, l_inPlugs[iii], inPlug)
for out in _outs:
ATTR.connect("{0}.output".format(newNode), out)
#pprint.pprint(d_setsSorted)
print len(d_sets)
#print len(d_setsSorted)
"""
l_inPlugs = {0: [u'input1X', u'input1Y', u'input1Z'],
1: [u'input2X', u'input2Y', u'input2Z']}
l_outplugs = [u'outputX', u'outputY', u'outputZ']
for operator,d_sets in d_modeToPlugs.iteritems():
d_setsSorted = LISTS. get_chunks(d_sets,3)
for nodeSet in d_setsSorted:
newNode = mc.createNode('multiplyDivide')
newNode = mc.rename(newNode,'optimize_{0}_mdNode'.format(_cnt))
_cnt+=1
l_new.append(newNode)
ATTR.set(newNode,'operation',operator)
for i,d_set in enumerate(nodeSet):
_ins = d_set['in']
_outs = d_set['out']
for iii,inPlug in enumerate(_ins):
if mc.objExists(inPlug):
ATTR.connect(inPlug, "{0}.{1}".format(newNode, l_inPlugs[iii][i]))
else:
ATTR.set(newNode,l_inPlugs[iii][i], inPlug)
for out in _outs:
ATTR.connect("{0}.{1}".format(newNode, l_outplugs[i]), out)
#pprint.pprint(d_setsSorted)
print len(d_sets)
print len(d_setsSorted)
"""
mc.delete(l_oldNodes)
return len(l_new)
def get_closest_point(source=None, targetSurface=None, loc=False):
"""
Get the closest point on a target surface/curve/mesh to a given point or object.
Evaluates to all sub shapes to get closest point for multi shape targets.
:parameters:
source(str/vector) -- source point or object
targetSurface -- surface to check transform, nurbsSurface, curve, mesh supported
loc -- whether to loc point found
:returns
position, distance, shape (list)
"""
_str_func = 'get_closest_point'
_point = False
if VALID.vectorArg(source) is not False:
_point = source
elif mc.objExists(source):
_point = POS.get(source)
if not _point: raise ValueError, "Must have point of reference"
_loc = mc.spaceLocator(n='get_closest_point_loc')[0]
POS.set(_loc, _point)
if SEARCH.is_shape(targetSurface):
_shapes = [targetSurface]
elif VALID.is_component(targetSurface):
_shapes = mc.listRelatives(VALID.get_component(targetSurface)[1],
s=True,
fullPath=True)
else:
_shapes = mc.listRelatives(targetSurface, s=True, fullPath=True)
if not _shapes:
log.error("|{0}| >> No shapes found. Skipping: {1}".format(
_str_func, targetSurface))
mc.delete(_loc)
return False
_l_res_positions = []
_l_res_shapes = []
_l_res_distances = []
for s in _shapes:
_type = VALID.get_mayaType(s)
if _type not in ['mesh', 'nurbsSurface', 'nurbsCurve']:
log.error(
"|{0}| >> Unsupported target surface type. Skipping: {1} |{2} | {3}"
.format(_str_func, s, _type))
_l_res_positions.append(False)
continue
if _type == 'mesh':
_node = mc.createNode('closestPointOnMesh')
ATTR.connect((_loc + '.translate'), (_node + '.inPosition'))
ATTR.connect((s + '.worldMesh'), (_node + '.inMesh'))
ATTR.connect((s + '.worldMatrix'), (_node + '.inputMatrix'))
_pos = ATTR.get(_node, 'position')
_tmpLoc = mc.spaceLocator(n='tmp')[0]
ATTR.connect((_node + '.position'), (_tmpLoc + '.translate'))
_l_res_positions.append(POS.get(_tmpLoc))
mc.delete(_node)
mc.delete(_tmpLoc)
elif _type == 'nurbsSurface':
closestPointNode = mc.createNode('closestPointOnSurface')
ATTR.set(closestPointNode, 'inPositionX', _point[0])
ATTR.set(closestPointNode, 'inPositionY', _point[1])
ATTR.set(closestPointNode, 'inPositionZ', _point[2])
ATTR.connect((s + '.worldSpace'),
(closestPointNode + '.inputSurface'))
_l_res_positions.append(ATTR.get(closestPointNode, 'position'))
mc.delete(closestPointNode)
elif _type == 'nurbsCurve':
_node = mc.createNode('nearestPointOnCurve')
p = []
distances = []
mc.connectAttr((_loc + '.translate'), (_node + '.inPosition'))
mc.connectAttr((s + '.worldSpace'), (_node + '.inputCurve'))
p = [
mc.getAttr(_node + '.positionX'),
mc.getAttr(_node + '.positionY'),
mc.getAttr(_node + '.positionZ')
]
_l_res_positions.append(p)
mc.delete(_node)
mc.delete(_loc)
if not _l_res_positions:
raise ValueError, "No positions found"
for p in _l_res_positions:
if p:
_l_res_distances.append(get_distance_between_points(_point, p))
else:
_l_res_distances.append('no')
closest = min(_l_res_distances)
_idx = _l_res_distances.index(closest)
_pos = _l_res_positions[_idx]
if not _pos:
return False
#raise ValueError,"Failed to find point"
if loc:
_loc = mc.spaceLocator(n='get_closest_point_loc')[0]
POS.set(_loc, _pos)
return _pos, _l_res_distances[_idx], _shapes[_idx]
def snap(obj=None,
targets=None,
position=True,
rotation=True,
rotateAxis=False,
rotateOrder=False,
rotatePivot=False,
scalePivot=False,
objPivot='rp',
objMode=None,
objLoc=False,
targetPivot='rp',
targetMode=None,
targetLoc=False,
queryMode=False,
space='w',
mark=False,
**kws):
"""
Core snap functionality.
:parameters:
obj(str): Object to modify
target(str): Objects to snap to
objPivot
targetPivot
objMode =
targetMode
position
rotation
rotateAxis
rotateOrder
scalePivot
space
mark
:returns
success(bool)
"""
try:
_str_func = 'snap'
try:
obj = obj.mNode
except:
pass
_obj = VALID.mNodeString(obj)
if targets is None:
log.debug("|{0}| >> self target... ".format(_str_func))
_targets = [_obj]
else:
_targets = VALID.mNodeStringList(targets)
reload(VALID)
_pivotObj = VALID.kw_fromDict(objPivot,
SHARED._d_pivotArgs,
noneValid=True)
_pivotTar = VALID.kw_fromDict(targetPivot,
SHARED._d_pivotArgs,
noneValid=True)
_space = VALID.kw_fromDict(space,
SHARED._d_spaceArgs,
noneValid=False,
calledFrom=__name__ + _str_func +
">> validate space")
log.debug(
"|{0}| >> obj: {1}({2}-{3}) | target:({4}-{5})({6}) | space: {7}".
format(_str_func, _obj, _pivotObj, objMode, _pivotTar, targetMode,
_targets, _space))
log.debug(
"|{0}| >> position: {1} | rotation:{2} | rotateAxis: {3} | rotateOrder: {4}"
.format(_str_func, position, rotation, rotateAxis, rotateOrder))
kws_xform = {'ws': False, 'os': False}
if _space == 'world':
kws_xform['ws'] = True
else:
kws_xform['os'] = True
#Mode type defaults...
if objMode is None:
if _pivotObj is 'boundingBox':
objMode = 'center'
elif _pivotObj in ['castCenter', 'castFar', 'castNear', 'axisBox']:
objMode = 'z+'
if targetMode is None:
if _pivotTar is 'boundingBox':
targetMode = 'center'
elif _pivotTar in ['castCenter', 'castFar', 'castNear', 'axisBox']:
targetMode = 'z+'
if _pivotTar in ['castFar', 'castAllFar', 'castNear', 'castAllNear']:
if targetMode == 'center':
log.debug(
"|{0}| >> Center target mode invalid with {1}. Changing to 'z+' "
.format(_str_func, _pivotTar))
targetMode = 'z+'
#cgmGEN.func_snapShot(vars())
if position or objLoc or targetLoc or rotatePivot or scalePivot:
kws_xform_move = copy.copy(kws_xform)
if _pivotTar == 'sp':
kws_xform_move['spr'] = True
else:
kws_xform_move['rpr'] = True
#>>>Target pos ------------------------------------------------------------------------------
log.debug(
"|{0}| >> Position True. Getting target pivot pos {1} ".format(
_str_func, _pivotTar))
l_nameBuild = [
'_'.join([NAMES.get_base(o) for o in _targets]), _pivotTar
]
if targetMode and _pivotTar not in [
'sp', 'rp', 'closestPoint', 'groundPos'
]:
l_nameBuild.append(targetMode)
l_pos = []
if _pivotTar in ['sp', 'rp']:
log.debug("|{0}| >> xform query... ".format(_str_func))
for t in _targets:
l_pos.append(POS.get(t, _pivotTar, _space))
pos_target = DIST.get_average_position(l_pos)
elif _pivotTar == 'closestPoint':
log.debug("|{0}|...closestPoint...".format(_str_func))
pos_target = DIST.get_by_dist(_obj,
_targets,
resMode='pointOnSurface')
else:
log.debug("|{0}| >> special query... ".format(_str_func))
_targetsSpecial = copy.copy(_targets)
if _pivotTar not in [
'axisBox', 'groundPos', 'castCenter', 'boundingBox'
]:
_targetsSpecial.insert(0, _obj)
pos_target = get_special_pos(_targetsSpecial, _pivotTar,
targetMode)
if not pos_target:
return log.error("No position detected")
if targetLoc:
_loc = mc.spaceLocator()[0]
mc.move(pos_target[0],
pos_target[1],
pos_target[2],
_loc,
ws=True)
mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild)))
log.debug("|{0}| >> Target pivot: {1}".format(
_str_func, pos_target))
#>>>Obj piv ------------------------------------------------------------------------------
log.debug("|{0}| >> Getting obj pivot pos {1} ".format(
_str_func, _pivotObj))
l_nameBuild = [NAMES.get_base(_obj), _pivotObj]
if objMode and _pivotObj not in [
'sp', 'rp', 'closestPoint', 'groundPos'
]:
l_nameBuild.append(objMode)
l_pos = []
if _pivotObj in ['sp', 'rp']:
log.debug("|{0}| >> xform query... ".format(_str_func))
pos_obj = POS.get(_obj, _pivotObj, _space)
elif _pivotObj == 'closestPoint':
log.debug("|{0}|...closestPoint...".format(_str_func))
pos_obj = DIST.get_by_dist(_targets[0],
_obj,
resMode='pointOnSurface')
else:
log.debug("|{0}| >> special query... ".format(_str_func))
pos_obj = get_special_pos(_obj, _pivotObj, objMode)
if objLoc:
_loc = mc.spaceLocator()[0]
mc.move(pos_obj[0], pos_obj[1], pos_obj[2], _loc, ws=True)
mc.rename(_loc, '{0}_loc'.format('_'.join(l_nameBuild)))
log.debug("|{0}| >> Obj pivot: {1}".format(_str_func, pos_obj))
if queryMode:
pprint.pprint(vars())
log.warning("|{0}| >> Query mode. No snap".format(_str_func))
mc.select([_obj] + _targets)
return True
#>>>Obj piv ------------------------------------------------------------------------------
if position:
log.debug("|{0}| >> Positioning... ".format(_str_func))
if _pivotObj == 'rp':
TRANS.position_set(obj, pos_target)
#POS.set(_obj, pos_target)
else:
p_start = TRANS.position_get(_obj)
_vector_to_objPivot = COREMATH.get_vector_of_two_points(
p_start, pos_obj)
_dist_base = DIST.get_distance_between_points(
p_start, pos_obj) #...get our base distance
p_result = DIST.get_pos_by_vec_dist(
pos_target, _vector_to_objPivot, -_dist_base)
cgmGEN.func_snapShot(vars())
POS.set(_obj, p_result)
if rotateAxis:
log.debug("|{0}|...rotateAxis...".format(_str_func))
mc.xform(obj,
ra=mc.xform(_targets[0], q=True, ra=True, **kws_xform),
p=True,
**kws_xform)
if rotateOrder:
log.debug("|{0}|...rotateOrder...".format(_str_func))
mc.xform(obj, roo=mc.xform(_targets[0], q=True, roo=True), p=True)
if rotation:
log.debug("|{0}|...rotation...".format(_str_func))
_t_ro = ATTR.get_enumValueString(_targets[0], 'rotateOrder')
_obj_ro = ATTR.get_enumValueString(obj, 'rotateOrder')
if _t_ro != _obj_ro:
#Creating a loc to get our target space rotateOrder into new space
log.debug(
"|{0}|...rotateOrders don't match...".format(_str_func))
_loc = mc.spaceLocator(n='tmp_roTranslation')[0]
ATTR.set(_loc, 'rotateOrder', _t_ro)
rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform)
mc.xform(_loc, ro=rot, **kws_xform)
mc.xform(_loc, roo=_obj_ro, p=True)
rot = mc.xform(_loc, q=True, ro=True, **kws_xform)
mc.delete(_loc)
else:
rot = mc.xform(_targets[0], q=True, ro=True, **kws_xform)
mc.xform(_obj, ro=rot, **kws_xform)
if rotatePivot:
log.debug("|{0}|...rotatePivot...".format(_str_func))
mc.xform(obj, rp=pos_target, p=True, **kws_xform)
if scalePivot:
log.debug("|{0}|...scalePivot...".format(_str_func))
mc.xform(obj, sp=pos_target, p=True, **kws_xform)
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
def orientByPlane(joints = None, axisAim = 'z+', axisUp = 'y+',
worldUpAxis = [0,1,0], planarMode = 'up', relativeOrient = True,
progressBar=None,
baseName = None, cleanUp = True, asMeta = True):
"""
Given a chain of joints, setup
:parameters:
planarMode - up/out - What plane to use
:returns
created(list)
"""
_str_func = 'orientPlane'
ml_joints = cgmMeta.validateObjListArg(joints,mayaType=['joint'],noneValid=False)
ml_joints = LISTS.get_noDuplicates(ml_joints)
mAxis_aim = VALID.simpleAxis(axisAim)
mAxis_up = VALID.simpleAxis(axisUp)
str_aim = mAxis_aim.p_string
str_up = mAxis_up.p_string
ml_delete = []
if str_aim == str_up:
raise ValueError,"axisAim and axisUp cannot be the same"
if len(ml_joints) < 3:
raise ValueError,"{0} > Need more than 3 joints".format(_str_func)
#First setup a dup chain of first and end, orient those ----------------------------------------------------------------
log.debug("|{0}| >> Setup tmp chain...".format(_str_func))
mStart = ml_joints[0].doDuplicate(parentOnly = True)
mEnd = ml_joints[-1].doDuplicate(parentOnly = True)
mEnd.parent = mStart
orientChain([mStart,mEnd], axisAim, axisUp, worldUpAxis, relativeOrient)
#Setup Loft curves and plane ----------------------------------------------------------------
log.debug("|{0}| >> Setup curves...".format(_str_func))
if planarMode == 'up':
crvUp = mAxis_up.p_string
crvDn = mAxis_up.inverse.p_string
else:
for a in 'xyz':
if a not in str_aim and a not in str_up:
mAxisCrv_tmp = VALID.simpleAxis(a+'+')
crvUp = mAxisCrv_tmp.p_string
crvDn = mAxisCrv_tmp.inverse.p_string
d_distance = DIST.get_distance_between_targets([mStart.mNode,mEnd.mNode])
l_crvs = []
for mObj in [mStart,mEnd]:
crv = mc.curve (d=1, ep = [DIST.get_pos_by_axis_dist(mObj.mNode, crvUp, d_distance),
DIST.get_pos_by_axis_dist(mObj.mNode, crvDn, d_distance)],
os=True)
log.debug("|{0}| >> Created: {1}".format(_str_func,crv))
l_crvs.append(crv)
_res_body = mc.loft(l_crvs, o = True, d = 1, po = 1 )
_inputs = mc.listHistory(_res_body[0],pruneDagObjects=True)
_tessellate = _inputs[0]
_d = {'format':2,#General
'polygonType':1,#'quads'
}
for a,v in _d.iteritems():
ATTR.set(_tessellate,a,v)
#Snap our joints ---------------------------------------------------------------------------------
for mJnt in ml_joints[1:-1]:
ml_children = mJnt.getChildren(asMeta=True)
for mChild in ml_children:
mChild.parent = False
SNAP.go(mJnt, _res_body[0], rotation=False, pivot='closestPoint')
for mChild in ml_children:
mChild.parent = mJnt
#Cleanup --------------------------------------------------------------------------------------------
if cleanUp:
mc.delete(_res_body + l_crvs)
mStart.delete()
orientChain(ml_joints, axisAim, axisUp, worldUpAxis, relativeOrient,progressBar)
return
l_start = []
l_end = []
mStartCrv = mc.curve()
mc.curve (d=1, ep = posList, os=True)
