def setUpPickerGroups(control=None, atr=None, groups=[]):
import cgm.core.classes.NodeFactory as nodeF
import cgm.core.cgm_Meta as cgmMeta
import cgm.core.lib.attribute_utils as ATTR
mGroups = cgmMeta.validateObjListArg(groups, 'cgmObject')
mControl = cgmMeta.validateObjArg(control, 'cgmObject')
ATTR.add(mControl.mNode,
atr,
'enum',
enumOptions=[mObj.p_nameBase for mObj in mGroups])
import cgm.core.classes.NodeFactory as nodeF
nodeF.build_conditionNetworkFromGroup(shortName,
chooseAttr=i,
controlObject="{0}.{1}".format(
mControl.mNode, atr))
#for i,mGrp in enumerate(mGroups):
# shortName = mGrp.getShortName()
#if log.getEffectiveLevel() == 10:log.debug(shortName)
#Let's get basic info for a good attr name
#d = nameTools.returnObjectGeneratedNameDict(shortName,ignore=['cgmTypeModifier','cgmType'])
#n = nameTools.returnCombinedNameFromDict(d)
# nodeF.build_conditionNetworkFromGroup(shortName, chooseAttr = i, controlObject = "{0}.{1}".format(mControl.mNode,atr))
return True
def __createnodeasdf__(self, nodeType, name):
'''
:param nodeType: type of node to create
:param name: name of the new node
'''
_str_func = 'cgmLight.__createnode__'
#Trying to use the light shape as the metaClass caused all sorts of issues. Best just to use the dag
_light = d_lightCalls.get(nodeType)(name=name)
_dag = cgmMeta.getTransform(_light)
ATTR.add(_dag,'mClass','string',value='cgmLight')
self.__justCreatedState__ = True
return _dag, True
def __init__(self,node=None,name=None,nodeType=None, **kws):
#>>> TO USE Cached instance ---------------------------------------------------------
_str_func = 'cgmLight.__init__'
if node is None:
if nodeType not in d_lightCalls.keys():
raise ValueError,"Unknown light node: {0}".format(nodeType)
if name is None:
name = nodeType
_light = d_lightCalls.get(nodeType)(name=name)
_dag = cgmMeta.getTransform(_light)
ATTR.add(_dag,'mClass','string',value='cgmLight',lock=True)
self.__justCreatedState__ = True
node = _dag
try: super(cgmLight, self).__init__(node,name, **kws)
except StandardError,error:
raise StandardError, "cgmLight.__init__ fail! | %s"%error
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 create_uvPickerNetwork(target=None,
name='iris',
mode=1,
enums=None,
count=9,
split=3):
_str_func = 'create_uvPickerNetwork'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
if count / split != split:
raise ValueError, "{0} || Split must divide evently to count. count: {1} | split: {2}".format(
_str_func, count, split)
if not target:
target = mc.group(em=True, name='uvPickerDefault')
if mode == 2:
log.debug(cgmGen.logString_msg(_str_func, '2 Attr mode'))
if not enums:
enums = ['{0}_{1}'.format(name, i) for i in range(2)]
for a in enums:
ATTR.add(target,
a,
'enum',
enumOptions=[str(i) for i in range(split)])
for a in 'U', 'V':
_a = 'res_{0}{1}'.format(name, a)
ATTR.add(target, _a, 'float', keyable=False, hidden=False)
ATTR.set_hidden(target, _a, False)
mMD = cgmMeta.cgmNode(name="{0}_picker_md".format(name),
nodeType='multiplyDivide')
mMD.operation = 2
mMD.input2X = split
mMD.input2Y = split
mMD.doConnectIn('input1X', "{0}.{1}".format(target, enums[0]))
mMD.doConnectIn('input1Y', "{0}.{1}".format(target, enums[1]))
mMD.doConnectOut('outputX', '{0}.res_{1}U'.format(target, name))
mMD.doConnectOut('outputY', '{0}.res_{1}V'.format(target, name))
else:
log.debug(cgmGen.logString_msg(_str_func, '1 Attr mode'))
_d_values = {
9: [
[.999, .666],
[.333, .666],
[.666, .666],
[.999, .333],
[.333, .333],
[.666, .333],
[.999, .999],
[.333, .999],
[.666, .999],
]
}
l_dat = _d_values.get(count)
if not l_dat:
raise ValueError, "{0} | count {1} not supported".format(
_str_func, count)
for a in 'U', 'V':
_a = 'res_{0}{1}'.format(name, a)
ATTR.add(target, _a, 'float', keyable=False, hidden=False)
ATTR.set_hidden(target, _a, False)
mPMA = cgmMeta.cgmNode(name="{0}_picker_pma".format(name),
nodeType='plusMinusAverage')
mPMA.operation = 1
ATTR.add(target, name, 'enum', enumOptions=[str(i) for i in range(9)])
mAttr = cgmMeta.cgmAttr(target, name)
for i, vSet in enumerate(l_dat):
_iterBase = "{0}_{1}".format(name, i)
if mc.objExists('%s_condNode' % _iterBase):
mc.delete('%s_condNode' % _iterBase)
mNode = cgmMeta.cgmNode(name="{0}_condNode".format(_iterBase),
nodeType='condition')
mNode.secondTerm = i
mNode.colorIfTrueR = vSet[0]
mNode.colorIfTrueG = vSet[1]
mNode.colorIfFalseR = 0
mNode.colorIfFalseG = 0
mAttr.doConnectOut('%s.firstTerm' % mNode.mNode)
ATTR.connect('%s.outColor' % mNode.mNode,
"{0}.input3D[{1}]".format(mPMA.mNode, i))
#attributes.doConnectAttr('%s.outColorR'%mNode.mNode,'%s.%s'%(c,self.connectToAttr))
mPMA.doConnectOut('output3Dx', '{0}.res_{1}U'.format(target, name))
mPMA.doConnectOut('output3Dy', '{0}.res_{1}V'.format(target, name))
def create_uvPickerNetworkBAK(target=None, name='iris', split=9):
_str_func = 'create_uvPickerNetwork'
log.debug("|{0}| >> ".format(_str_func) + '-' * 80)
_d_values = {
9: [
[.999, .666],
[.333, .666],
[.666, .666],
[.999, .333],
[.333, .333],
[.666, .333],
[.999, .999],
[.333, .999],
[.666, .999],
]
}
l_dat = _d_values.get(split)
if not l_dat:
raise ValueError, "{0} | split {1} not supported".format(
_str_func, split)
if not target:
target = mc.group(em=True, name='uvPickerDefault')
md_pmas = {}
for a in 'U', 'V':
_a = '{0}{1}'.format(name, a)
ATTR.add(target, _a, 'float', keyable=False, hidden=False)
ATTR.set_hidden(target, _a, False)
#if mc.objExists('%s_pma'%_iterBase):
#mc.delete('%s_condNode'%_iterBase)
mPMA = cgmMeta.cgmNode(name="{0}_pma".format(_iterBase),
nodeType='plusMinusAverage')
mPMA.operation = 1
md_pmas[a] = mPMA
ATTR.add(target, name, 'enum', enumOptions=[str(i) for i in range(9)])
mAttr = cgmMeta.cgmAttr(target, name)
#Pma nodes -------------------------------------------------
#Condition loop ----------------------------------------
#place 2d texture = number of rolls
for i, vSet in enumerate(l_dat):
_iterBase = "{0}_{1}".format(name, i)
if mc.objExists('%s_condNode' % _iterBase):
mc.delete('%s_condNode' % _iterBase)
mNode = cgmMeta.cgmNode(name="{0}_condNode".format(_iterBase),
nodeType='condition')
mNode.secondTerm = i
mNode.colorIfTrueR = vSet[0]
mNode.colorIfTrueR = vSet[1]
mNode.colorIfFalseR = 0
mNode.colorIfFalseG = 0
#attributes.doSetAttr(i_node.mNode,'colorIfTrueR',1)
#attributes.doSetAttr(i_node.mNode,'colorIfFalseR',0)
#i_node.colorIfTrueR = 1
#i_node.colorIfTrueR = 0
mAttr.doConnectOut('%s.firstTerm' % i_node.mNode)
attributes.doConnectAttr('%s.outColorR' % i_node.mNode,
'%s.%s' % (c, self.connectToAttr))
def siblingSDK_wip(mTarget = 'L_ring_limb_part',matchType = False,
d_attrs = d_default):
_str_func = 'siblingSDK_wip'
log.info(cgmGEN.logString_start(_str_func))
if mTarget is None:
mTarget = cgmMeta.asMeta(sl=1)
if mTarget:mTarget = mTarget[0]
else:
mTarget = cgmMeta.asMeta(mTarget)
#mParent -----------------------------------------------------------------------------
mParent = mTarget.moduleParent
mParentSettings = mParent.rigNull.settings
#pprint.pprint([mParent,mParentSettings])
_settings = mParentSettings.mNode
#Siblings get ------------------------------------------------------------------------
mSiblings = mTarget.atUtils('siblings_get',excludeSelf=False, matchType = matchType)
md = {}
#Need to figure a way to get the order...
for i,mSib in enumerate(mSiblings):
log.info(cgmGEN.logString_start(_str_func, mSib.__repr__()))
_d = {}
ml_fk = mSib.atUtils('controls_get','fk')
if not ml_fk:
log.warning('missing fk. Skippping...')
continue
if 'thumb' not in mSib.mNode:
ml_fk = ml_fk[1:]
_d['fk'] = ml_fk
ml_sdk = []
str_part = mSib.get_partNameBase()
for mFK in ml_fk:
mSDK = mFK.getMessageAsMeta('sdkGroup')
if not mSDK:
mSDK = mFK.doGroup(True,True,asMeta=True,typeModifier = 'sdk')
ml_sdk.append(mSDK)
for a,d in d_attrs.iteritems():
log.info("{0} | ...".format(a))
_aDriver = "{0}_{1}".format(a,i)
#_aDriver = "{0}_{1}".format(str_part,a)
if not mParentSettings.hasAttr(_aDriver):
ATTR.add(_settings, _aDriver, attrType='float', keyable = True)
for mSDK in ml_sdk:
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, d['d']),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = 0, value = 0)
#+ ------------------------------------------------------------------
pos_v = d.get('+')
pos_d = d.get('+d', 1.0)
if pos_v:
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, d['d']),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = pos_d, value = pos_v)
#- ----------------------------------------------------------
neg_v = d.get('-')
neg_d = d.get('-d', -1.0)
if neg_v:
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, d['d']),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = neg_d, value = neg_v)
_d['sdk'] = ml_sdk
md[mSib] = _d
def SDK_wip(ml = [], matchType = False,
d_attrs = d_default, skipLever = True, skipFKBase = []):
_str_func = 'siblingSDK_wip'
log.info(cgmGEN.logString_start(_str_func))
if not ml:
ml = cgmMeta.asMeta(sl=1)
else:
ml = cgmMeta.asMeta(ml)
#mParent -----------------------------------------------------------------------------
mParent = ml[0].moduleParent
mParentSettings = mParent.rigNull.settings
#pprint.pprint([mParent,mParentSettings])
_settings = mParentSettings.mNode
#Siblings get ------------------------------------------------------------------------
#mSiblings = mTarget.atUtils('siblings_get',excludeSelf=False, matchType = matchType)
mSiblings = ml
md = {}
d_int = {}
#Need to figure a way to get the order...
for i,mSib in enumerate(mSiblings):
log.info(cgmGEN.logString_start(_str_func, mSib.__repr__()))
_d = {}
ml_fk = mSib.atUtils('controls_get','fk')
if not ml_fk:
log.warning('missing fk. Skippping...')
continue
if skipLever or skipFKBase:
if i in skipFKBase:
ml_fk = ml_fk[1:]
elif skipLever and mSib.getMessage('rigBlock') and mSib.rigBlock.getMayaAttr('blockProfile') in ['finger']:
ml_fk = ml_fk[1:]
#if 'thumb' not in mSib.mNode:
# ml_fk = ml_fk[1:]
_d['fk'] = ml_fk
ml_sdk = []
for ii,mFK in enumerate(ml_fk):
mSDK = mFK.getMessageAsMeta('sdkGroup')
if not mSDK:
mSDK = mFK.doGroup(True,True,asMeta=True,typeModifier = 'sdk')
ml_sdk.append(mSDK)
if not d_int.get(ii):
d_int[ii] = []
d_int[ii].append(mSDK)
_d['sdk'] = ml_sdk
md[mSib] = _d
#pprint.pprint(md)
#pprint.pprint(d_int)
#return
for a,d in d_attrs.iteritems():
log.info(cgmGEN.logString_sub(_str_func,a))
for i,mSib in enumerate(mSiblings):
log.info(cgmGEN.logString_sub(_str_func,mSib))
d_sib = copy.deepcopy(d)
d_idx = d.get(i,{})
if d_idx:
_good = True
for k in ['d','+d','-d','+','-']:
if not d_idx.get(k):
_good = False
break
if _good:
log.info(cgmGEN.logString_msg(_str_func,"Found d_idx on mSib | {0}".format(d_idx)))
d_use = copy.deepcopy(d_idx)
else:d_use = copy.deepcopy(d_sib)
d2 = md[mSib]
str_part = mSib.getMayaAttr('cgmName') or mSib.get_partNameBase()
#_aDriver = "{0}_{1}".format(a,i)
_aDriver = "{0}_{1}".format(a,str_part)
if not mParentSettings.hasAttr(_aDriver):
ATTR.add(_settings, _aDriver, attrType='float', keyable = True)
log.info(cgmGEN.logString_msg(_str_func,"d_sib | {0}".format(d_sib)))
for ii,mSDK in enumerate(d2.get('sdk')):
d_cnt = d_idx.get(ii,{})
if d_cnt:
log.info(cgmGEN.logString_msg(_str_func,"Found d_cnt on mSib | {0}".format(d_cnt)))
d_use = copy.deepcopy(d_cnt)
else:d_use = copy.deepcopy(d_sib)
log.info(cgmGEN.logString_msg(_str_func,"{0}| {1} | {2}".format(i,ii,d_use)))
if d_use.get('skip'):
continue
d_ease = d_use.get('ease',{})
v_ease = d_ease.get(ii,None)
l_rev = d_sib.get('reverse',[])
if issubclass( type(d_use['d']), dict):
d_do = d_use.get('d')
else:
d_do = {d_use['d'] : d_use}
for k,d3 in d_do.iteritems():
if d3.get('skip'):
continue
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, k),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = 0, value = 0)
#+ ------------------------------------------------------------------
pos_v = d3.get('+')
pos_d = d_use.get('+d', 1.0)
if v_ease is not None:
pos_v = pos_v * v_ease
if i in l_rev:
print("...rev pos")
pos_v*=-1
ATTR.set_max("{0}.{1}".format(_settings, _aDriver),pos_d)
if pos_v:
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, k),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = pos_d, value = pos_v)
#- ----------------------------------------------------------
neg_v = d3.get('-')
neg_d = d_use.get('-d', -1.0)
if v_ease is not None:
neg_v = neg_v * v_ease
if i in l_rev:
print("...rev neg")
neg_v*=-1
ATTR.set_min("{0}.{1}".format(_settings, _aDriver),neg_d)
if neg_v:
mc.setDrivenKeyframe("{0}.{1}".format(mSDK.mNode, k),
currentDriver = "{0}.{1}".format(_settings, _aDriver),
itt='linear',ott='linear',
driverValue = neg_d, value = neg_v)