def get_dat(target = None, differential=False, module = dynFKPresets):
_str_func = 'get_dat'
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 = ATTR.get_attrsByTypeDict(mTar.mNode)
#pprint.pprint(_d)
_res = {}
_tar = mTar.mNode
for section,l in d_attrMap.get(_key).iteritems():
log.debug(cgmGEN.logString_msg(_str_func,section))
for a in l:
if a in l_ignore:
continue
try:
_v = ATTR.get(_tar,a)
log.debug(cgmGEN.logString_msg(_str_func,"{0} | {1}".format(a,_v)))
except Exception,err:
log.error("Failed to query: {0} | {1} | {2}".format(_tar, a, err))
if _v is not None:
_res[str(a)] = _v
def chain_rebuild(self, idx = None, objs = None, **kws):
_str_func = 'chain_rebuild'
dat = self.get_dat()
mNucleus = dat['mNucleus']
mHairSysShape = dat['mHairSysShape']
l_do = []
if idx:
if dat['chains'].get(idx):
l_do.append(idx)
else:
l_do = dat['chains'].keys()
log.debug(cgmGEN.logString_msg(_str_func, 'To do: {0}'.format(l_do)))
for idx in l_do:
log.debug(cgmGEN.logString_sub(_str_func, 'On: {0}'.format(idx)))
_d = dat['chains'][idx]
ml_targets = _d['mTargets']
self.targets_disconnect(idx)#...remove contraints
mDynFKParent = ml_targets[0].getMessageAsMeta('dynFKParentGroup')
if mDynFKParent:
ml_targets[0].p_parent = mDynFKParent.p_parent
mDynFKParent.delete()
self.chain_deleteByIdx(idx)
self.chain_create(ml_targets,**kws)
self.targets_connect(idx)#...remove contraints
log.debug(cgmGEN.logString_msg(_str_func, 'chain {0} done'.format(idx)))
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 curveInfo(curve, baseName='curveInfo'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Creates a curve lenght measuring node
ARGUMENTS:
polyFace(string) - face of a poly
RETURNS:
length(float)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
_str_func = 'curveInfo'
if VALID.is_shape(curve):
l_shapes = [curve]
else:
l_shapes = mc.listRelatives(curve, s=True, fullPath=True)
if len(l_shapes) > 1:
raise ValueError, cgmGeneral.logString_msg(
__str_func, "Must have one shape. Found {0} | {1}".format(
len(l_shapes), l_shapes))
infoNode = create(baseName, 'curveInfo')
ATTR.connect((l_shapes[0] + '.worldSpace'), (infoNode + '.inputCurve'))
return infoNode
def fncMayaSett_query(self):
_str_func = 'ui.fncMayaSett_query'
log.info("|{0}| >>...".format(_str_func))
d_settings = {'world': PU._worldSettings, 'anim': PU._animSettings}
d_nameToCheck = {
'world': {
'worldUp': MAYASET.sceneUp_get,
'linear': MAYASET.distanceUnit_get,
'angular': MAYASET.angularUnit_get
},
'anim': {
'frameRate': MAYASET.frameRate_get,
'defaultInTangent': MAYASET.defaultInTangent_get,
'defaultOutTangent': MAYASET.defaultOutTangent_get,
'weightedTangents': MAYASET.weightedTangents_get
},
}
#pprint.pprint(d_toDo)
for k, l in d_settings.iteritems():
log.info(cgmGEN.logString_sub(_str_func, k))
_d = self.mDat.__dict__.get(d_nameToKey.get(k))
for d in l:
try:
log.debug(cgmGEN.logString_msg(_str_func, d))
_type = d.get('t')
_dv = d.get('dv')
_name = d.get('n')
_value = _d[_name] #_d[_name].getValue()
fnc = d_nameToCheck.get(k, {}).get(_name)
if fnc:
_current = fnc()
if _value != _current:
log.warning(
cgmGEN.logString_msg(
_str_func,
"name: {0} | setting: {1} | found :{2}".format(
_name, _value, _current)))
else:
log.debug(
cgmGEN.logString_msg(
_str_func,
"name: {0} | setting: {1} | found :{2}".format(
_name, _value, _current)))
else:
log.warning("No function found for {0} | {1}".format(
k, _name))
except Exception, err:
log.error("Failure {0} | {1} | {2}".format(k, _name, err))
def get_constraintsTo(node=None,
fullPath=True,
typeFilter=None,
typeMask=None):
"""
Get the constraints on a given node
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsTo'
node = VALID.mNodeString(node)
_res = mc.listRelatives(node, type='constraint', fullPath=fullPath) or []
_res = LISTS.get_noDuplicates(_res)
if typeFilter:
typeFilter = VALID.listArg(typeFilter)
for i, t in enumerate(typeFilter):
if 'Constraint' not in t:
typeFilter[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func,
'typeFilter: {0}'.format(typeFilter)))
_res_filter = []
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeFilter:
_res_filter.append(o)
_res = _res_filter
if typeMask:
typeMask = VALID.listArg(typeMask)
for i, t in enumerate(typeMask):
if 'Constraint' not in t:
typeMask[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func, 'typeMask: {0}'.format(typeMask)))
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeMask:
_res.remove(o)
log.debug(
cgmGEN.logString_msg(_str_func, 'removing: {0}'.format(o)))
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
def get_selectedFromChannelBox(attributesOnly=False):
"""
Returns a list of selected object attributes from the channel box
:parameters:
attributesOnly(bool): Whether you want
Keyword arguments:
returnRaw() -- whether you just want channels or objects combined with selected attributes
"""
_str_func = 'get_selectedFromChannelBox'
_sel = mc.ls(sl=True)
ChannelBoxName = mel.eval('$tmp = $gChannelBoxName')
sma = mc.channelBox(ChannelBoxName, query=True, sma=True)
ssa = mc.channelBox(ChannelBoxName, query=True, ssa=True)
sha = mc.channelBox(ChannelBoxName, query=True, sha=True)
soa = mc.channelBox(ChannelBoxName, query=True, soa=True)
channels = []
if sma:
log.debug(cgmGEN.logString_msg(_str_func, "sma: {0}".format(sma)))
channels.extend(sma)
if ssa:
log.debug(cgmGEN.logString_msg(_str_func, "ssa: {0}".format(sma)))
channels.extend(ssa)
if sha:
log.debug(cgmGEN.logString_msg(_str_func, "sha: {0}".format(sha)))
channels.extend(sha)
if soa:
log.debug(cgmGEN.logString_msg(_str_func, "soa: {0}".format(soa)))
channels.extend(soa)
if channels and _sel:
_channels_long = []
for c in channels:
_channels_long.append(c)
"""
_l = ATTR.get_nameLong(_sel[0],c)
if '.weight' not in _l:
_channels_long.append(_l)
else:
_channels_long.append(c)"""
if attributesOnly:
return _channels_long
else:
_res = []
for item in _sel:
for attr in _channels_long:
_comb = "{0}.{1}".format(item, attr)
if mc.objExists(_comb):
_res.append(_comb)
return _res
return False
def fncMayaSett_do(self, world=False, anim=False):
_str_func = 'ui.fncMayaSett_do'
log.info("|{0}| >>...".format(_str_func))
d_settings = {'world': PU._worldSettings, 'anim': PU._animSettings}
d_toDo = {}
if world:
d_toDo['world'] = d_settings['world']
if anim:
d_toDo['anim'] = d_settings['anim']
d_nameToSet = {
'world': {
'worldUp': MAYASET.sceneUp_set,
'linear': MAYASET.distanceUnit_set,
'angular': MAYASET.angularUnit_set
},
'anim': {
'frameRate': MAYASET.frameRate_set,
'defaultInTangent': MAYASET.defaultInTangent_set,
'defaultOutTangent': MAYASET.defaultOutTangent_set,
'weightedTangents': MAYASET.weightedTangets_set
},
}
#pprint.pprint(d_toDo)
for k, l in d_toDo.iteritems():
log.info(cgmGEN.logString_sub(_str_func, k))
#_d = self.d_tf[k]
_d = self.mDat.__dict__.get(d_nameToKey.get(k))
for d in l:
try:
log.info(cgmGEN.logString_msg(_str_func, d))
_type = d.get('t')
_dv = d.get('dv')
_name = d.get('n')
_value = _d[_name] #_d[_name].getValue()
fnc = d_nameToSet.get(k, {}).get(_name)
log.info(
cgmGEN.logString_msg(
_str_func,
"name: {0} | value: {1}".format(_name, _value)))
if fnc:
fnc(_value)
else:
log.warning("No function found for {0} | {1}".format(
k, _name))
except Exception, err:
log.error("Failure {0} | {1} | {2}".format(k, _name, err))
def frameRate_set(arg):
_str_func = 'frameRate_set'
log.debug(cgmGEN.logString_start(_str_func))
if VALID.valueArg(arg):
_arg = '{0}fps'.format(arg)
else:
d_validArgs = {
'ntsc': ['n', 'ntsc'],
'pal': ['p', 'pal'],
'film': ['f', 'film'],
'game': ['g', 'game'],
'ntscf': ['ntscf']
}
_arg = VALID.kw_fromDict(arg,
d_validArgs,
calledFrom=_str_func,
noneValid=True)
if not _arg:
_arg = arg
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(time=_arg)
def get_planeIntersect(planeSource=None,
target=None,
planeAxis='z+',
objAxis='z+',
mark=False):
_str_func = 'get_planeIntersect'
if target:
mTarget = cgmMeta.asMeta(target)
else:
mTarget = cgmMeta.asMeta(mc.ls(sl=1))
if not mTarget:
return log.error(cgmGEN.logString_msg(_str_func, 'No Target'))
mTarget = mTarget[0]
mObj = cgmMeta.asMeta(planeSource)
planePoint = VALID.euclidVector3Arg(mObj.p_position)
planeNormal = VALID.euclidVector3Arg(mObj.getAxisVector(planeAxis))
rayPoint = VALID.euclidVector3Arg(mTarget.p_position)
rayDirection = VALID.euclidVector3Arg(mTarget.getAxisVector(objAxis))
plane = EUCLID.Plane(
EUCLID.Point3(planePoint.x, planePoint.y, planePoint.z),
EUCLID.Point3(planeNormal.x, planeNormal.y, planeNormal.z))
pos = plane.intersect(
EUCLID.Line3(
EUCLID.Point3(rayPoint.x, rayPoint.y, rayPoint.z),
EUCLID.Vector3(rayDirection.x, rayDirection.y, rayDirection.z)))
if mark:
LOC.create(position=pos, name='pewpew_planeIntersect')
return pos
def defaultTangents_set(arg, inTangent=True, outTangent=True):
_str_func = 'defaultTangents_set'
log.debug(cgmGEN.logString_start(_str_func))
d_validArgs = {
'linear': ['ln', 'linear'],
'spline': ['sp', 'spline'],
'clamped': ['cl', 'clamped'],
'flat': ['fl', 'flat'],
'plateau': ['pl', 'plateau'],
'auto': ['au', 'auto']
}
_arg = VALID.kw_fromDict(arg, d_validArgs, calledFrom=_str_func)
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
#Couldn't use True for setting the Tangent type had to use _arg
_d = {'g': 1}
if inTangent:
_d['itt'] = _arg
if outTangent:
_d['ott'] = _arg
mc.keyTangent(**_d)
def rebuild_controlShape(self):
_short = self.mNode
_str_func = '[{0}] rebuild_controlShape'.format(_short)
if not self.atUtils('is_rigged'):
log.warning(cgmGEN.logString_msg(_str_func, "Must be rigged"))
return False
bb_sizeBase = TRANS.bbSize_get(self.mNode, True)
pprint.pprint(bb_sizeBase)
def frameRate_set(arg, fixFractionalSlider=True):
_str_func = 'frameRate_set'
log.debug(cgmGEN.logString_start(_str_func))
if VALID.valueArg(arg):
_arg = '{0}fps'.format(arg)
else:
d_validArgs = {
'ntsc': ['n', 'ntsc'],
'pal': ['p', 'pal'],
'film': ['f', 'film'],
'game': ['g', 'game'],
'ntscf': ['ntscf']
}
_arg = VALID.kw_fromDict(arg,
d_validArgs,
calledFrom=_str_func,
noneValid=True)
if not _arg:
_arg = arg
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(time=_arg)
if fixFractionalSlider:
log.debug(cgmGEN.logString_msg(_str_func, 'fixFractionalSlider...'))
_current = mc.currentTime(q=True)
mc.playbackOptions(
animationStartTime=int(
mc.playbackOptions(q=True, animationStartTime=True)),
animationEndTime=int(
mc.playbackOptions(q=True, animationEndTime=True)),
max=int(mc.playbackOptions(q=True, max=True)),
min=int(mc.playbackOptions(q=True, min=True)),
)
mc.currentTime(int(_current))
def sceneUp_set(arg):
_str_func = 'sceneUp_set'
log.debug(cgmGEN.logString_start(_str_func))
d_validArgs = {'y': ['y'], 'z': ['z']}
_arg = VALID.kw_fromDict(arg, d_validArgs, calledFrom=_str_func)
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.upAxis(ax=_arg, rv=1)
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 angularUnit_set(arg):
_str_func = 'angularUnit_set'
log.debug(cgmGEN.logString_start(_str_func))
d_validArgs = {
'deg': ['deg', 'degree', 'degrees'],
'rad': ['rad', 'radian']
}
_arg = VALID.kw_fromDict(arg, d_validArgs, calledFrom=_str_func)
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(angle=_arg)
def distanceUnit_set(arg):
_str_func = 'distanceUnit_set'
log.debug(cgmGEN.logString_start(_str_func))
d_validArgs = {
'm': ['meter', 'metre'],
'cm': ['centimeter', 'centi'],
'mm': ['milimeter', 'mili'],
'yd': ['yard'],
'in': ['inch', 'inches'],
'ft': ['feet', 'foot']
}
_arg = VALID.kw_fromDict(arg, d_validArgs, calledFrom=_str_func)
log.debug(
cgmGEN.logString_msg(_str_func,
"| arg: {0} | validated: {1}".format(arg, _arg)))
mc.currentUnit(linear=_arg)
def get_planeIntersect(self,
target=None,
planeAxis='z+',
objAxis='z+',
mark=True):
_short = self.mNode
_str_func = '[{0}] get_planeIntersect'.format(_short)
if target:
mTarget = cgmMeta.asMeta(target)
else:
mTarget = cgmMeta.asMeta(mc.ls(sl=1))
if not mTarget:
return log.error(cgmGEN.logString_msg(_str_func, 'No Target'))
mTarget = mTarget[0]
if not self.atUtils('is_rigged'):
mObj = self
else:
mObj = self.moduleTarget.eyeLook
planePoint = VALID.euclidVector3Arg(mObj.p_position)
planeNormal = VALID.euclidVector3Arg(mObj.getAxisVector(planeAxis))
rayPoint = VALID.euclidVector3Arg(mTarget.p_position)
rayDirection = VALID.euclidVector3Arg(mTarget.getAxisVector(objAxis))
plane = EUCLID.Plane(
EUCLID.Point3(planePoint.x, planePoint.y, planePoint.z),
EUCLID.Point3(planeNormal.x, planeNormal.y, planeNormal.z))
pos = plane.intersect(
EUCLID.Line3(
EUCLID.Point3(rayPoint.x, rayPoint.y, rayPoint.z),
EUCLID.Vector3(rayDirection.x, rayDirection.y, rayDirection.z)))
if mark:
LOC.create(position=pos, name='pewpew')
return pos
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 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)
log.debug("mesh: %s" % mesh)
log.debug("mi_loc.mNode: %s" % mi_loc.mNode)
log.debug("aimAxis: %s" % aimAxis)
log.debug("latheAxis: %s" % latheAxis)
log.debug("maxDistance: %s" % maxDistance)
hit = RayCast.cast(mesh,
mi_loc.mNode,
aimAxis,
offsetMode='vector',
offsetDistance=vectorOffset,
maxDistance=maxDistance).get('hit')
if not hit:
log.debug(
cgmGEN.logString_msg(
_str_func, "No hit, alternate method | {0}".format(
rotateValue)))
hit = DIST.get_pos_by_axis_dist(mi_loc.mNode, aimAxis,
maxDistance)
if hit:
if DIST.get_distance_between_points(pos_base,
hit) > maxDistance:
log.debug("Max distance exceeded. Using alternative")
hit = DIST.get_pos_by_axis_dist(
mi_loc.mNode, aimAxis, maxDistance)
#d_castReturn = RayCast.findMeshIntersectionFromObjectAxis(mesh, mi_loc.mNode, axis=aimAxis, #maxDistance = maxDistance, firstHit=False) or {}
# d_hitReturnFromValue[rotateValue] = d_castReturn
#if closestInRange:
#hit = d_castReturn.get('near') or False
try:
log.info(
"|{0}| >> Initial delete fail. attempting chmod... ".
format(_str_func))
os.chmod(_path, stat.S_IWRITE)
os.remove(_path)
except Exception, e:
for arg in e.args:
log.error(arg)
raise RuntimeError, "Stop"
else:
if _d_weirdFiles:
pprint.pprint(_d_weirdFiles)
log.warning(
cgmGEN.logString_msg(
_str_func,
"Found {0} files".format(len(_d_weirdFiles.keys()))))
else:
log.warning(cgmGEN.logString_msg(_str_func, "No files found."))
return
"""
if cleanPyc:
_l_failed = []
log.debug("|{0}| >> Found {1} pyc files under: {2}".format(_str_func,len(_l_pyc),path))
for _file in _l_pyc:
#for k in _l_ordered_list:
#if k in _l_pycd:
log.debug("|{0}| >> Attempting to clean pyc for: {1} ".format(_str_func,_file))
if not _file.endswith('.pyc'):
raise ValueError,"Should NOT be here"
try:
def wing_temp(d_wiring=d_wiring_r, mode='slidingPosition'):
"""
"""
try:
_str_func = 'wing_temp'
log.debug(cgmGEN.logString_start(_str_func))
ml_roots = []
ml_parts = []
ml_rigNulls = []
ml_blendDrivers = []
#Dat get...
for part in d_wiring['modules']:
mPart = cgmMeta.asMeta(part)
mRigNull = mPart.rigNull
ml_parts.append(mPart)
ml_rigNulls.append(mRigNull)
ml_roots.append(mRigNull.rigRoot)
ml_joints = mRigNull.msgList_get('blendJoints')
if not ml_joints:
for plug in 'fkAttachJoints', 'fkJoints':
ml_test = mRigNull.msgList_get(plug)
if ml_test:
ml_joints = ml_test
break
ml_blendDrivers.append(ml_joints[0])
pprint.pprint(vars())
#Generate driver locs...
for d, s in d_wiring['driven'].iteritems():
mPart = ml_parts[d]
mRoot = ml_roots[d]
mRigNull = ml_rigNulls[d]
mAttach = mRigNull.getMessageAsMeta('attachDriver')
log.info(cgmGEN.logString_sub(_str_func, "{0} | {1}".format(d, s)))
#...loc -----------------------------------------------------------------------
log.info(cgmGEN.logString_msg(_str_func, 'loc...'))
mLoc = mRoot.getMessageAsMeta('featherDriver')
if mLoc:
mLoc.delete()
mLoc = ml_roots[d].doLoc()
mLoc.rename("{0}_featherLoc".format(mPart.p_nameBase))
mLoc.p_parent = mRoot.masterGroup.p_parent
mLoc.v = False
mLoc.doStore('cgmAlias', 'feather')
mRoot.connectChildNode(mLoc.mNode, 'featherDriver', 'mPart')
#...drivers ------------------------------------------------------------
ml_drivers = [ml_blendDrivers[v] for v in s]
l_drivers = [mObj.mNode for mObj in ml_drivers]
_vList = DIST.get_normalizedWeightsByDistance(
mLoc.mNode, l_drivers)
_orient = mc.orientConstraint(l_drivers,
mLoc.mNode,
maintainOffset=0)
l_constraints = [_orient]
if mode == 'slidingPosition':
_point = mc.pointConstraint(l_drivers,
mLoc.mNode,
maintainOffset=0)
l_constraints.append(_point)
else:
_point = mc.pointConstraint(mAttach.mNode,
mLoc.mNode,
maintainOffset=1)
for c in l_constraints:
CONSTRAINT.set_weightsByDistance(c[0], _vList)
ATTR.set(_orient[0], 'interpType', 2)
mLoc.dagLock()
mDynGroup = mRoot.dynParentGroup
mDynGroup.addDynParent(mLoc)
mDynGroup.rebuild()
_len = len(ATTR.get_enumList(mRoot.mNode, 'space'))
mRoot.space = _len - 1
return True
except Exception, err:
cgmGEN.cgmException(Exception, err)
def get_constraintsFrom(node=None,
fullPath=True,
typeFilter=None,
typeMask=None):
"""
Get the constraints a given node drives
:parameters:
node(str): node to query
fullPath(bool): How you want list
:returns
list of constraints(list)
"""
_str_func = 'get_constraintsFrom'
node = VALID.mNodeString(node)
_res = mc.listConnections(node,
source=False,
destination=True,
skipConversionNodes=True,
type='constraint') or []
_res = LISTS.get_noDuplicates(_res)
#_l_objectConstraints = get(node)
#for c in _l_objectConstraints:
#if c in _res:_res.remove(c)
if typeFilter:
typeFilter = VALID.listArg(typeFilter)
for i, t in enumerate(typeFilter):
if 'Constraint' not in t:
typeFilter[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func,
'typeFilter: {0}'.format(typeFilter)))
_res_filter = []
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeFilter:
_res_filter.append(o)
_res = _res_filter
if typeMask:
typeMask = VALID.listArg(typeMask)
for i, t in enumerate(typeMask):
if 'Constraint' not in t:
typeMask[i] = t + 'Constraint'
log.debug(
cgmGEN.logString_msg(_str_func, 'typeMask: {0}'.format(typeMask)))
for o in _res:
_type = VALID.get_mayaType(o)
if _type in typeMask:
_res.remove(o)
log.debug(
cgmGEN.logString_msg(_str_func, 'removing: {0}'.format(o)))
if fullPath:
return [NAMES.long(o) for o in _res]
return _res
def ik_bankRollShapes(self):
try:
_str_func = 'bankRollShapes'
log.debug(cgmGEN.logString_sub(_str_func))
mBlock = self.mBlock
mRigNull = self.mRigNull
mHandleFactory = self.mHandleFactory
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
ml_formHandles = self.ml_formHandles
ml_fkShapes = []
mBallFK = False
mToeFK = False
mToeIK = False
mBallIK = False
_minRot = -90,
_maxRot = 90
mMesh_tmp = self.mBlock.atUtils('get_castMesh', pivotEnd=1)
str_meshShape = mMesh_tmp.getShapes()[0]
#if self.mPivotHelper:
# size_pivotHelper = POS.get_bb_size(self.mPivotHelper.mNode)
#else:
# size_pivotHelper = POS.get_bb_size(ml_formHandles[-1].mNode)
#reload(SHAPECASTER)
_d_cast = {
'vectorOffset': _offset,
'points': 15,
#'minRot':-90,'maxRot':90,
'closedCurve': False
}
_max = None
if self.mBall:
try:
_max = RAYS.get_dist_from_cast_axis(
self.mBall.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
except:
_max = 1
_d_cast['maxDistance'] = _max
crvBall = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mBall.mNode,
**_d_cast)
if not self.mToe:
pos = RAYS.get_cast_pos(self.mBall.mNode,
shapes=mMesh_tmp.mNode)
pos_me = self.mBall.p_position
dist = DIST.get_distance_between_points(pos, pos_me) / 2
pos_end = DIST.get_pos_by_vec_dist(pos_me, [0, 0, 1], dist)
mDup = self.mBall.doDuplicate(po=True)
mDup.p_position = pos_end
crvBall2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mDup.mNode, **_d_cast)
CURVES.connect([crvBall, crvBall2], 7)
mDup.delete()
mHandleFactory.color(crvBall, controlType='sub')
mBallFK = self.mBall.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mBallFK.mNode,
crvBall,
True,
replaceShapes=True)
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func,
"Ball Ik control..."))
mBallIK = self.mBall.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mBallIK.mNode,
crvBall,
True,
replaceShapes=True)
mRigNull.connectChildNode(mBallIK, 'controlIKBall',
'rigNull') #Connect
mBallIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallIK.doStore('cgmTypeModifier', 'ik')
mBallIK.doName()
mBallIK.connectChildNode(self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
#Hinge ===================================================================
log.debug(
cgmGEN.logString_msg(_str_func,
"Ball Hinge Ik control..."))
#Need to make our cast locs
mStart = mBallIK.doCreateAt(setClass=1)
mEnd = mBallIK.doCreateAt(setClass=1)
pos1_start = self.mBall.getParent(asMeta=1).p_position
pos2_start = mEnd.p_position
vec_to_end = MATH.get_vector_of_two_points(
pos1_start, pos2_start)
vec_to_start = MATH.get_vector_of_two_points(
pos2_start, pos1_start)
mStart.p_position = DIST.get_average_position(
[pos1_start, pos2_start])
#DIST.get_pos_by_vec_dist(pos1_start,vec_to_end,_offset)#
mEnd.p_position = DIST.get_pos_by_vec_dist(
pos2_start, vec_to_start, _offset)
crv1 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mStart.mNode, **_d_cast)
crv2 = SHAPECASTER.createMeshSliceCurve(
str_meshShape, mEnd.mNode, **_d_cast)
CURVES.connect([crv1, crv2], 7)
mBallHingeIK = self.mBall.doCreateAt(setClass=True)
mRigNull.connectChildNode(mBallHingeIK, 'controlIKBallHinge',
'rigNull') #Connect
mBallHingeIK.connectChildNode(
self.mBall.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mHandleFactory.color(crv1, controlType='sub')
CORERIG.shapeParent_in_place(mBallHingeIK.mNode,
crv1,
True,
replaceShapes=True)
mBallHingeIK.doCopyNameTagsFromObject(self.mBall.mNode,
ignore=['cgmType'])
mBallHingeIK.doStore('cgmNameModifier', 'hinge')
mBallHingeIK.doStore('cgmTypeModifier', 'ik')
mBallHingeIK.doName()
for mObj in mStart, mEnd:
mObj.delete()
ml_fkShapes.append(cgmMeta.asMeta(crv1))
ml_fkShapes.append(cgmMeta.validateObjArg(crvBall, 'cgmObject'))
if self.mToe:
if not _max:
_max = RAYS.get_dist_from_cast_axis(
self.mToe.mNode,
self.d_orientation['str'][2],
shapes=str_meshShape)
_d_cast['maxDistance'] = _max
crv = SHAPECASTER.createMeshSliceCurve(str_meshShape,
self.mToe.mNode, **_d_cast)
"""
crv = CURVES.create_controlCurve(self.mToe.mNode, shape='circle',
direction = _jointOrientation[0]+'+',
sizeMode = 'fixed',
size = size_pivotHelper[0])"""
mHandleFactory.color(crv, controlType='sub')
mToeFK = self.mToe.getMessageAsMeta('fkJoint')
CORERIG.shapeParent_in_place(mToeFK.mNode,
crv,
True,
replaceShapes=True)
ml_fkShapes.append(cgmMeta.validateObjArg(crv, 'cgmObject'))
if self.str_ikRollSetup == 'control':
log.debug(cgmGEN.logString_msg(_str_func, "Toe Ik control..."))
mToeIK = self.mToe.doCreateAt(setClass=True)
CORERIG.shapeParent_in_place(mToeIK.mNode,
crv,
True,
replaceShapes=True)
mRigNull.connectChildNode(mToeIK, 'controlIKToe',
'rigNull') #Connect
mToeIK.doCopyNameTagsFromObject(self.mToe.mNode,
ignore=['cgmType'])
mToeIK.doStore('cgmTypeModifier', 'ik')
mToeIK.doName()
mToeIK.connectChildNode(self.mToe.fkJoint.blendJoint.mNode,
'blendJoint') #Connect
mMesh_tmp.delete()
return ml_fkShapes
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def settings(self, settingsPlace=None, ml_targets=None):
try:
_str_func = 'rp'
log_start(_str_func)
log.debug("|{0}| >> settings: {1}...".format(_str_func, settingsPlace))
mBlock = self.mBlock
mRigNull = self.mRigNull
_offset = self.v_offset
_jointOrientation = self.d_orientation['str']
if settingsPlace == None:
settingsPlace = mBlock.getEnumValueString('settingsPlace')
if settingsPlace == 'cog':
mCog = mRigNull.getMessageAsMeta('rigRoot')
if mCog:
log.debug("|{0}| >> Settings is cog...".format(_str_func))
mRigNull.connectChildNode(mCog, 'settings',
'rigNull') #Connect
return mCog
else:
log.warning(
"|{0}| >> Settings. Cog option but no cog found...".format(
_str_func))
settingsPlace = 'start'
mSettingsHelper = mBlock.getMessageAsMeta('settingsHelper')
if settingsPlace in ['start', 'end']:
if settingsPlace == 'start':
_mTar = ml_targets[0]
else:
_mTar = ml_targets[self.int_handleEndIdx]
#_settingsSize = _offset * 2
if not mSettingsHelper:
mMesh_tmp = mBlock.atUtils('get_castMesh')
str_meshShape = mMesh_tmp.getShapes()[0]
d_directions = {
'up': 'y+',
'down': 'y-',
'in': 'x+',
'out': 'x-'
}
str_settingsDirections = d_directions.get(
mBlock.getEnumValueString('settingsDirection'), 'y+')
pos = RAYS.get_cast_pos(_mTar.mNode,
str_settingsDirections,
shapes=str_meshShape)
if not pos:
log.debug(
cgmGEN.logString_msg(_str_func, 'standard IK end'))
pos = _mTar.getPositionByAxisDistance(
str_settingsDirections, _offset * 5)
vec = MATH.get_vector_of_two_points(_mTar.p_position, pos)
newPos = DIST.get_pos_by_vec_dist(pos, vec, _offset * 4)
_settingsSize = _offset * 2
mSettingsShape = cgmMeta.validateObjArg(CURVES.create_fromName(
'gear',
_settingsSize,
'{0}+'.format(_jointOrientation[2]),
baseSize=1.0),
'cgmObject',
setClass=True)
mSettingsShape.doSnapTo(_mTar.mNode)
#SNAPCALLS.get_special_pos([_mTar,str_meshShape],'castNear',str_settingsDirections,False)
mSettingsShape.p_position = newPos
mMesh_tmp.delete()
SNAP.aim_atPoint(
mSettingsShape.mNode,
_mTar.p_position,
aimAxis=_jointOrientation[0] + '+',
mode='vector',
vectorUp=_mTar.getAxisVector(_jointOrientation[0] + '-'))
else:
mSettingsShape = mSettingsHelper.doDuplicate(po=False)
mSettingsShape.parent = _mTar
mSettings = mSettingsShape
CORERIG.match_orientation(mSettings.mNode, _mTar.mNode)
ATTR.copy_to(self.mModule.mNode,
'cgmName',
mSettings.mNode,
driven='target')
mSettings.doStore('cgmTypeModifier', 'settings')
mSettings.doName()
self.mHandleFactory.color(mSettings.mNode, controlType='sub')
mRigNull.connectChildNode(mSettings, 'settings',
'rigNull') #Connect
#cgmGEN.func_snapShot(vars())
#mSettings.select()
else:
raise ValueError, "Unknown settingsPlace: {1}".format(
settingsPlace)
return mSettings
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err, localDat=vars())
def create_Scene_batchFile(dat=[],
batchFile=None,
process=True,
postProcesses=True,
deleteAfterProcess=False):
_str_func = 'create_Scene_batchFile'
cgmGEN.log_start(_str_func)
if batchFile is None:
var_project = cgmMeta.cgmOptionVar('cgmVar_projectCurrent',
defaultValue='')
mProject = PROJECT.data(filepath=var_project.value)
d_paths = mProject.userPaths_get()
mPath_root = PATHS.Path(d_paths['root'])
if mPath_root.exists():
log.debug('Root | : {0}'.format(mPath_root.asFriendly()))
else:
log.debug('Root | Invalid Path: {0}'.format(mPath_root))
mPath_content = PATHS.Path(d_paths['content'])
if os.path.exists(mPath_content):
log.debug('Root | : {0}'.format(mPath_content))
else:
log.debug('Root | Invalid Path: {0}'.format(mPath_content))
_batchPath = os.path.join(mPath_root.asFriendly(), 'mrsScene_batch.py')
log.debug("batchFile : {0}".format(_batchPath))
l_pre = [
'import maya', 'from maya import standalone',
'standalone.initialize()', 'from cgm.core.mrs import Scene',
'import maya.mel as mel', 'from maya.api import OpenMaya as om2',
'om2.MGlobal.displayInfo("Begin")', 'import maya.cmds as mc',
'mc.loadPlugin("fbxmaya")',
'mc.workspace("{0}",openWorkspace=1)'.format(mPath_content),
'import cgm.core.mrs.lib.batch_utils as MRSBATCH', ''
]
l_post = [
'except Exception,err:', ' print err',
' import msvcrt#...waits for key',
' om2.MGlobal.displayInfo("Hit a key to continue")',
' msvcrt.getch()', '', 'om2.MGlobal.displayInfo("End")',
'standalone.uninitialize()'
]
log.debug(cgmGEN.logString_sub(_str_func, "Checks ..."))
l_paths = []
l_dirs = []
#l_check = VALID.listArg(f)
l_mFiles = []
l_batch = []
#if not l_check:
#log.debug(cgmGEN.logString_msg(_str_func,"No file passed. Using current"))
#l_check = [mc.file(q=True, sn=True)]
_dat = ['dat = [']
for d2 in dat:
_dat.append('{')
for k, d in d2.iteritems():
if k == 'objs':
if d:
_l_tmp = ','.join("'{0}'".format(o) for o in d)
_dat.append('"{0}" : [{1}],'.format(k, _l_tmp))
else:
_dat.append("'objs' : [ ],")
elif 'Path' in k:
_l_tmp = ','.join("'{0}'".format(o) for o in d)
_dat.append('"{0}" : [{1}],'.format(k, _l_tmp))
else:
_dat.append('"{0}" : "{1}",'.format(k, d))
_dat.append('},')
_dat.append(']')
mTar = PATHS.Path(_batchPath)
_l = "try:Scene.BatchExport(dat)"
#_l = "try:MRSBATCH.process_blocks_rig('{0}',postProcesses = {1})".format(mFile.asString(),postProcesses)
if mTar.getWritable():
if mTar.exists():
os.remove(mTar)
log.warning("Writing file: {0}".format(_batchPath))
with open(_batchPath, 'a') as TMP:
for l in l_pre + _dat + [_l] + l_post:
TMP.write('{0}\n'.format(l))
l_batch.append(mTar)
else:
log.warning("Not writable: {0}".format(_batchPath))
if process:
log.debug(cgmGEN.logString_sub(_str_func, "Processing ..."))
log.warning("Processing file: {0}".format(mTar.asFriendly()))
#subprocess.call([sys.argv[0].replace("maya.exe","mayapy.exe"),f.asFriendly()])
subprocess.Popen(
[
sys.argv[0].replace("maya.exe", "mayapy.exe"), '-i',
mTar.asFriendly()
],
creationflags=subprocess.CREATE_NEW_CONSOLE) # env=my_env
if deleteAfterProcess:
os.remove(f)
return
for f in l_check:
mFile = PATHS.Path(f)
if not mFile.exists():
log.error("Invalid file: {0}".format(f))
continue
log.debug(cgmGEN.logString_sub(_str_func))
_path = mFile.asFriendly()
l_paths.append(_path)
_name = mFile.name()
_d = mFile.up().asFriendly()
log.debug(cgmGEN.logString_msg(_str_func, _name))
_batchPath = os.path.join(_d, _name + '_batch.py')
log.debug(cgmGEN.logString_msg(_str_func, "batchPath: " + _batchPath))
log.debug(cgmGEN.logString_msg(_str_func, "template: " + _path))
mTar = PATHS.Path(_batchPath)
_l = "try:MRSBATCH.process_blocks_rig('{0}',postProcesses = {1})".format(
mFile.asString(), postProcesses)
if mTar.getWritable():
if mTar.exists():
os.remove(mTar)
log.warning("Writing file: {0}".format(_batchPath))
with open(_batchPath, 'a') as TMP:
for l in l_pre + [_l] + l_post:
TMP.write('{0}\n'.format(l))
l_batch.append(mTar)
else:
log.warning("Not writable: {0}".format(_batchPath))
if process:
log.debug(cgmGEN.logString_sub(_str_func, "Processing ..."))
for f in l_batch:
log.warning("Processing file: {0}".format(f.asFriendly()))
#subprocess.call([sys.argv[0].replace("maya.exe","mayapy.exe"),f.asFriendly()])
subprocess.Popen(
[
sys.argv[0].replace("maya.exe", "mayapy.exe"), '-i',
f.asFriendly()
],
creationflags=subprocess.CREATE_NEW_CONSOLE) # env=my_env
if deleteAfterProcess:
os.remove(f)
def process_blocks_rig(f=None, blocks=None, postProcesses=1, **kws):
_str_func = 'process_blocks_rig'
#cgmGEN.log_start(_str_func)
mFile = PATHS.Path(f)
if not mFile.exists():
raise ValueError, "Invalid file: {0}".format(f)
_path = mFile.asFriendly()
log.info("Good Path: {0}".format(_path))
"""
if 'template' in _path:
_newPath = _path.replace('template','build')
else:"""
_name = mFile.name()
_d = mFile.up().asFriendly()
log.debug(cgmGEN.logString_msg(_str_func, _name))
_newPath = os.path.join(_d,
_name + '_BUILD.{0}'.format(mFile.getExtension()))
log.info("New Path: {0}".format(_newPath))
#cgmGEN.logString_msg(_str_func,'File Open...')
mc.file(_path, open=1, f=1)
#cgmGEN.logString_msg(_str_func,'Process...')
T1 = time.time()
get_time = cgmGEN.get_timeString
try:
if not blocks:
#cgmGEN.logString_sub(_str_func,'No blocks arg')
ml_masters = r9Meta.getMetaNodes(mTypes='cgmRigBlock',
nTypes=['transform', 'network'],
mAttrs='blockType=master')
for mMaster in ml_masters:
#cgmGEN.logString_sub(_str_func,mMaster)
RIGBLOCKS.contextual_rigBlock_method_call(mMaster,
'below',
'atUtils',
'changeState',
'rig',
forceNew=False)
ml_context = BLOCKGEN.get_rigBlock_heirarchy_context(
mMaster, 'below', True, False)
l_fails = []
for mSubBlock in ml_context:
_state = mSubBlock.getState(False)
if _state != 4:
l_fails.append(mSubBlock)
if l_fails:
log.info('The following failed...')
pprint.pprint(l_fails)
raise ValueError, "Modules failed to rig: {0}".format(
l_fails)
log.info("Begin Rig Prep cleanup...")
'''
Begin Rig Prep process
'''
mPuppet = mMaster.moduleTarget #...when mBlock is your masterBlock
#str(datetime.timedelta(seconds=v))
if postProcesses:
l_timeReports = []
if kws.get('mirrorVerify', 1):
print(cgmGEN._str_hardBreak)
log.info('mirror_verify...')
t1 = time.clock()
mPuppet.atUtils('mirror_verify', 1)
t2 = time.clock()
l_timeReports.append(
['mirrorVerify', get_time(t2 - t1)])
if kws.get('gatherSpaceDrivers', 1):
log.info('collect worldSpace...')
t1 = time.clock()
mPuppet.atUtils('collect_worldSpaceObjects')
t2 = time.clock()
l_timeReports.append(
['gatherSpaceDrivers',
get_time(t2 - t1)])
if kws.get('qss', 1):
print(cgmGEN._str_hardBreak)
log.info('qss...')
t1 = time.clock()
mPuppet.atUtils('qss_verify',
puppetSet=1,
bakeSet=1,
deleteSet=1,
exportSet=1)
t2 = time.clock()
l_timeReports.append(['qss', get_time(t2 - t1)])
if kws.get('deleteUnusedShaders'):
print(cgmGEN._str_hardBreak)
log.info('Delete unused shaders...')
t1 = time.clock()
MRSPOST.shaders_getUnused(delete=True)
t2 = time.clock()
l_timeReports.append(
['deleteUnusedShaders',
get_time(t2 - t1)])
if kws.get('deleteCGMLightGroup'):
print(cgmGEN._str_hardBreak)
log.info('Delete cgm shaders...')
t1 = time.clock()
try:
mc.delete('cgmLightGroup')
except:
pass
t2 = time.clock()
l_timeReports.append(
['deleteUnusedShaders',
get_time(t2 - t1)])
if kws.get('proxyMesh', 1):
print(cgmGEN._str_hardBreak)
log.info('proxyMesh...')
t1 = time.clock()
mPuppet.atUtils('proxyMesh_verify', 1)
t2 = time.clock()
l_timeReports.append(['proxyMesh', get_time(t2 - t1)])
if kws.get('puppetMesh', 1):
print(cgmGEN._str_hardBreak)
log.info('puppetMesh...')
t1 = time.clock()
mPuppet.atUtils('puppetMesh_create', **{
'unified': True,
'skin': True
})
t2 = time.clock()
l_timeReports.append(['puppetMesh', get_time(t2 - t1)])
if kws.get('hideVisSub', 1):
print(cgmGEN._str_hardBreak)
log.info('hideVisSub...')
t1 = time.clock()
for i, mSubBlock in enumerate(ml_context):
if not i:
continue
try:
mSubBlock.moduleTarget.rigNull.settings.visSub = 0
except Exception, err:
log.error(mSubBlock)
log.error(err)
t2 = time.clock()
l_timeReports.append(['hideVisSub', get_time(t2 - t1)])
if kws.get('hideJointAxis'):
print(cgmGEN._str_hardBreak)
log.info('Hide axis on all joints...')
t1 = time.clock()
for mObj in cgmMeta.asMeta(mc.ls(type='joint')):
mObj.displayLocalAxis = 0
t2 = time.clock()
l_timeReports.append(
['hideJointAxis',
get_time(t2 - t1)])
if kws.get('removeRefs'):
print(cgmGEN._str_hardBreak)
log.info('Remove Refs...')
t1 = time.clock()
MRSPOST.refs_remove()
t2 = time.clock()
l_timeReports.append(['removeRefs', get_time(t2 - t1)])
if kws.get('ihi', 1):
print(cgmGEN._str_hardBreak)
log.info('ihi...')
t1 = time.clock()
mPuppet.atUtils('rigNodes_setAttr', 'ihi', 0)
t2 = time.clock()
l_timeReports.append(['ihi', get_time(t2 - t1)])
if kws.get('connectRig', 1):
print(cgmGEN._str_hardBreak)
log.info('rig connect...')
t1 = time.clock()
mPuppet.atUtils('rig_connectAll')
t2 = time.clock()
l_timeReports.append(['connectRig', get_time(t2 - t1)])
log.info('...')
if kws.get('controllerVerify', 1):
print(cgmGEN._str_hardBreak)
if cgmGEN.__mayaVersion__ >= 2018:
log.info('controller_verify...')
t1 = time.clock()
mPuppet.atUtils('controller_verify')
log.info('...')
t2 = time.clock()
l_timeReports.append(
['controllerVerify',
get_time(t2 - t1)])
if kws.get('blocksGather', 1):
print(cgmGEN._str_hardBreak)
t1 = time.clock()
mGrp = BUILDERUTILS.gather_rigBlocks()
if kws.get('blocksParent', 1):
mGrp.p_parent = mPuppet
mGrp.v = False
t2 = time.clock()
l_timeReports.append(
['blocksGather', get_time(t2 - t1)])
if kws.get('worldGather'):
print(cgmGEN._str_hardBreak)
log.info('Gathering world dags...')
t1 = time.clock()
MRSPOST.gather_worldStuff()
t2 = time.clock()
l_timeReports.append(
['worldGather', get_time(t2 - t1)])
if kws.get('deleteUnusedLayers'):
print(cgmGEN._str_hardBreak)
log.info('Deleting Unused Layers...')
t1 = time.clock()
MRSPOST.layers_getUnused(delete=True)
t2 = time.clock()
l_timeReports.append(
['deleteUnusedLayers',
get_time(t2 - t1)])
print(cgmGEN._str_hardBreak)
print(cgmGEN.logString_sub("Batch", 'Times'))
for i, pair_time in enumerate(l_timeReports):
print(" {0} | ['{1}'] | {2} ".format(
i, pair_time[0], pair_time[1]))
except Exception, err:
log.error(err)
def create_MRS_batchFile(f=None,
blocks=[None],
process=False,
postProcesses=True,
deleteAfterProcess=False,
gatherOptionVars=True):
_str_func = 'create_MRS_batchFile'
cgmGEN.log_start(_str_func)
l_pre = [
'import maya', 'from maya import standalone',
'standalone.initialize()', 'from maya.api import OpenMaya as om2',
'om2.MGlobal.displayInfo("Begin")', 'import maya.cmds as mc',
'mc.loadPlugin("matrixNodes")',
'import cgm.core.mrs.lib.batch_utils as MRSBATCH'
]
l_post = [
'except:', ' import msvcrt#...waits for key',
' om2.MGlobal.displayInfo("Hit a key to continue")',
' msvcrt.getch()', 'om2.MGlobal.displayInfo("End")',
'standalone.uninitialize()'
]
log.debug(cgmGEN.logString_sub(_str_func, "Checks ..."))
l_paths = []
l_dirs = []
l_check = VALID.listArg(f)
l_mFiles = []
l_batch = []
if not l_check:
log.debug(
cgmGEN.logString_msg(_str_func, "No file passed. Using current"))
l_check = [mc.file(q=True, sn=True)]
for f in l_check:
mFile = PATHS.Path(f)
if not mFile.exists():
log.error("Invalid file: {0}".format(f))
continue
log.debug(cgmGEN.logString_sub(_str_func))
_path = mFile.asFriendly()
l_paths.append(_path)
_name = mFile.name()
_d = mFile.up().asFriendly()
log.debug(cgmGEN.logString_msg(_str_func, _name))
_batchPath = os.path.join(_d, _name + '_MRSbatch.py')
log.debug(cgmGEN.logString_msg(_str_func, "batchPath: " + _batchPath))
log.debug(cgmGEN.logString_msg(_str_func, "template: " + _path))
mTar = PATHS.Path(_batchPath)
_l = "try:MRSBATCH.process_blocks_rig('{0}',postProcesses = {1})".format(
mFile.asString(), postProcesses)
if mTar.getWritable():
if mTar.exists():
os.remove(mTar)
log.warning("Writing file: {0}".format(_batchPath))
with open(_batchPath, 'a') as TMP:
for l in l_pre + [_l] + l_post:
TMP.write('{0}\n'.format(l))
l_batch.append(mTar)
else:
log.warning("Not writable: {0}".format(_batchPath))
if process:
log.debug(cgmGEN.logString_sub(_str_func, "Processing ..."))
for f in l_batch:
log.warning("Processing file: {0}".format(f.asFriendly()))
#subprocess.call([sys.argv[0].replace("maya.exe","mayapy.exe"),f.asFriendly()])
subprocess.Popen(
[
sys.argv[0].replace("maya.exe", "mayapy.exe"), '-i',
f.asFriendly()
],
creationflags=subprocess.CREATE_NEW_CONSOLE) # env=my_env
if deleteAfterProcess:
os.remove(f)
'''
def attach_toShape(obj=None,
targetShape=None,
connectBy='parent',
driver=None):
"""
:parameters:
obj - transform to attach
targetShape(str) - Curve, Nurbs, Mesh
connectBy(str)
parent - parent to track transform
parentGroup - parent to group and have group follow
conPoint - just point contraint
conPointGroup - pointConstrain group
conPointOrientGroup - point/orient constrain group
conParentGroup - parent Constrain group
None - just the tracker nodes
:returns:
resulting dat
"""
try:
_str_func = 'attach_toShape'
mObj = cgmMeta.validateObjArg(obj, 'cgmObject')
mDriver = cgmMeta.validateObjArg(driver, 'cgmObject', noneValid=True)
targetShape = VALID.mNodeString(targetShape)
log.debug("targetShape: {0}".format(targetShape))
#Get our data...
d_closest = DIST.get_closest_point_data(targetShape, mObj.mNode)
log.debug("|{0}| >> jnt: {1} | {2}".format(_str_func, mObj.mNode,
d_closest))
#pprint.pprint(d_closest)
md_res = {}
if d_closest['type'] in ['mesh', 'nurbsSurface']:
log.debug("|{0}| >> Follicle mode...".format(_str_func))
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
log.debug("_shape: {0}".format(_shape))
l_follicleInfo = NODES.createFollicleOnMesh(_shape)
i_follicleTrans = cgmMeta.asMeta(l_follicleInfo[1],
'cgmObject',
setClass=True)
i_follicleShape = cgmMeta.asMeta(l_follicleInfo[0], 'cgmNode')
#> Name...
i_follicleTrans.doStore('cgmName', mObj)
i_follicleTrans.doStore('cgmTypeModifier', 'surfaceTrack')
i_follicleTrans.doName()
_trackTransform = i_follicleTrans.mNode
#>Set follicle value...
if d_closest['type'] == 'mesh':
i_follicleShape.parameterU = d_closest['parameterU']
i_follicleShape.parameterV = d_closest['parameterV']
else:
i_follicleShape.parameterU = d_closest['normalizedU']
i_follicleShape.parameterV = d_closest['normalizedV']
_res = [i_follicleTrans.mNode, i_follicleShape.mNode]
md_res['mFollicle'] = i_follicleTrans
md_res['mFollicleShape'] = i_follicleShape
else:
log.debug("|{0}| >> Curve mode...".format(_str_func))
#d_returnBuff = distance.returnNearestPointOnCurveInfo(obj,crv)
_shape = SHAPES.get_nonintermediate(d_closest['shape'])
mPOCI = cgmMeta.cgmNode(nodeType='pointOnCurveInfo')
mc.connectAttr("%s.worldSpace" % _shape,
"%s.inputCurve" % mPOCI.mNode)
mPOCI.parameter = d_closest['parameter']
mTrack = mObj.doCreateAt()
mTrack.doStore('cgmName', mObj)
mTrack.doStore('cgmType', 'surfaceTrack')
mTrack.doName()
_trackTransform = mTrack.mNode
mc.connectAttr("%s.position" % mPOCI.mNode,
"%s.t" % _trackTransform)
mPOCI.doStore('cgmName', mObj)
mPOCI.doName()
_res = [mTrack.mNode, mPOCI.mNode]
if mDriver:
if d_closest['type'] in ['nurbsSurface']:
mFollicle = i_follicleTrans
mFollShape = i_follicleShape
minU = ATTR.get(_shape, 'minValueU')
maxU = ATTR.get(_shape, 'maxValueU')
minV = ATTR.get(_shape, 'minValueV')
maxV = ATTR.get(_shape, 'maxValueV')
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
#mLoc = mObj.doLoc()
str_baseName = "{0}_to_{1}".format(mDriver.p_nameBase,
mObj.p_nameBase)
mPlug_normalizedU = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumU = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumU".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_normalizedV = cgmMeta.cgmAttr(
mDriverLoc.mNode,
"{0}_normalizedV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_sumV = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_sumV".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
#res_closest = DIST.create_closest_point_node(mLoc.mNode, mCrv_reparam.mNode,True)
log.debug("|{0}| >> Closest info {1}".format(_str_func, _res))
srfNode = mc.createNode('closestPointOnSurface')
mc.connectAttr("%s.worldSpace[0]" % _shape,
"%s.inputSurface" % srfNode)
mc.connectAttr("%s.translate" % mDriverLoc.mNode,
"%s.inPosition" % srfNode)
#mc.connectAttr("%s.position" % srfNode, "%s.translate" % mLoc.mNode, f=True)
#mClosestPoint = cgmMeta.validateObjArg(srfNode,setClass=True)
#mClosestPoint.doStore('cgmName',mObj)
#mClosestPoint.doName()
log.debug("|{0}| >> paramU {1}.parameterU | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterU')))
log.debug("|{0}| >> paramV {1}.parameterV | {2}".format(
_str_func, srfNode, ATTR.get(srfNode, 'parameterV')))
l_argBuild = []
mPlug_uSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_uSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
mPlug_vSize = cgmMeta.cgmAttr(mDriverLoc.mNode,
"{0}_vSize".format(str_baseName),
attrType='float',
hidden=False,
lock=False)
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_vSize.p_combinedName, maxV, minV))
l_argBuild.append("{0} = {1} - {2}".format(
mPlug_uSize.p_combinedName, maxU, minU))
l_argBuild.append("{0} = {1} + {2}.parameterU".format(
mPlug_sumU.p_combinedName, minU, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedU.p_combinedName,
mPlug_sumU.p_combinedName, mPlug_uSize.p_combinedName))
l_argBuild.append("{0} = {1} + {2}.parameterV".format(
mPlug_sumV.p_combinedName, minV, srfNode))
l_argBuild.append("{0} = {1} / {2}".format(
mPlug_normalizedV.p_combinedName,
mPlug_sumV.p_combinedName, mPlug_vSize.p_combinedName))
for arg in l_argBuild:
log.debug("|{0}| >> Building arg: {1}".format(
_str_func, arg))
NODEFACTORY.argsToNodes(arg).doBuild()
ATTR.connect(mPlug_normalizedU.p_combinedShortName,
'{0}.parameterU'.format(mFollShape.mNode))
ATTR.connect(mPlug_normalizedV.p_combinedShortName,
'{0}.parameterV'.format(mFollShape.mNode))
md_res['mDriverLoc'] = mDriverLoc
elif d_closest['type'] in ['curve', 'nurbsCurve']:
mDriverLoc = mDriver.doLoc()
mc.pointConstraint(mDriver.mNode, mDriverLoc.mNode)
_resClosest = DIST.create_closest_point_node(
mDriverLoc.mNode, _shape, True)
_loc = _resClosest[0]
md_res['mDriverLoc'] = mDriverLoc
md_res['mDrivenLoc'] = cgmMeta.asMeta(_loc)
md_res['mTrack'] = mTrack
else:
log.warning(
cgmGEN.logString_msg(
_str_func,
"Shape type not currently supported for driver setup. Type: {0}"
.format(d_closest['type'])))
#if connectBy is None:
#return _res
if connectBy == 'parent':
mObj.p_parent = _trackTransform
elif connectBy == 'conPoint':
mc.pointConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'conParent':
mc.parentConstraint(_trackTransform,
mObj.mNode,
maintainOffset=True)
elif connectBy == 'parentGroup':
mGroup = mObj.doGroup(asMeta=True)
#_grp = TRANS.group_me(obj,True)
#TRANS.parent_set(_grp,_trackTransform)
mGroup.p_parent = _trackTransform
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conPointOrientGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.pointConstraint(mLoc.mNode, mGroup.mNode)
mc.orientConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy == 'conParentGroup':
mLoc = mObj.doLoc()
mLoc.p_parent = _trackTransform
mGroup = mObj.doGroup(asMeta=True)
mc.parentConstraint(mLoc.mNode, mGroup.mNode)
_res = _res + [mGroup.mNode]
elif connectBy is None:
pass
else:
raise NotImplementedError, "|{0}| >>invalid connectBy: {1}".format(
_str_func, connectBy)
if md_res:
return _res, md_res
return _res
#pprint.pprint(vars())
except Exception, err:
cgmGEN.cgmExceptCB(Exception, err)
