def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.l_created = lists.returnListNoDuplicates(self.l_created)
self.l_return = lists.returnListNoDuplicates(self.l_return)
if self._createMode in ['curve','jointChain','group','follicle'] and self.l_return:
if self._createMode == 'group':
bufferList = []
for i,o in enumerate(self.l_created):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.l_created = bufferList
elif self._createMode =='follicle':
if self.mode == 'midPoint':
log.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.l_created:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
log.info("uv: {0}".format(uv))
follicle = nodes.createFollicleOnMesh(mesh)
log.info("follicle: {0}".format(follicle))
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.l_created:
try:mc.delete(o)
except:pass
if self._createMode == 'curve' and len(self.l_return)>1:
if len(self.l_return) > 1:
self.l_created = [curves.curveFromPosList(self.l_return)]
else:
log.warning("Need at least 2 points for a curve")
elif self._createMode == 'jointChain':
self.l_created = []
mc.select(cl=True)
for pos in self.l_return:
self.l_created.append( mc.joint (p = (pos[0], pos[1], pos[2]),radius = 1) )
log.debug( self.l_created)
if self.d_tagAndName:
for o in self.l_created:
try:
i_o = cgmMeta.cgmNode(o)
for tag in self.d_tagAndName.keys():
i_o.doStore(tag,self.d_tagAndName[tag])
i_o.doName()
except StandardError,error:
log.error(">>> clickMesh >> Failed to tag and name: %s | error: %s"%(i_o.p_nameShort,error))
def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.createdList = lists.returnListNoDuplicates(self.createdList)
self.returnList = lists.returnListNoDuplicates(self.returnList)
if self.createMode in ['curve','jointChain','group','follicle'] and self.returnList:
if self.createMode == 'group':
bufferList = []
for i,o in enumerate(self.createdList):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.createdList = bufferList
elif self.createMode =='follicle':
if self.mode == 'midPoint':
guiFactory.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.createdList:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
follicle = nodes.createFollicleOnMesh(mesh)
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.createdList:
try:mc.delete(o)
except:pass
if self.createMode == 'curve' and len(self.returnList)>1:
if len(self.returnList) > 1:
self.createdList = [mc.curve (d=3, p = self.returnList , ws=True)]
else:
guiFactory.warning("Need at least 2 points for a curve")
elif self.createMode == 'jointChain':
self.createdList = []
mc.select(cl=True)
for pos in self.returnList:
self.createdList.append( mc.joint (p = (pos[0], pos[1], pos[2])) )
self.reset()
def finalize(self):
"""
Press action. Clears buffers.
"""
#Clean our lists...
self.createdList = lists.returnListNoDuplicates(self.createdList)
self.returnList = lists.returnListNoDuplicates(self.returnList)
if self.createMode in ['curve','jointChain','group','follicle'] and self.returnList:
if self.createMode == 'group':
bufferList = []
for i,o in enumerate(self.createdList):
buffer = rigging.groupMeObject(o,False)
bufferList.append(buffer)
try:mc.delete(o)
except:pass
self.createdList = bufferList
elif self.createMode =='follicle':
if self.mode == 'midPoint':
guiFactory.warning("Mid point mode doesn't work with follicles")
return
bufferList = []
for o in self.createdList:
mesh = attributes.doGetAttr(o,'cgmHitTarget')
if mc.objExists(mesh):
uv = distance.returnClosestUVToPos(mesh,distance.returnWorldSpacePosition(o))
follicle = nodes.createFollicleOnMesh(mesh)
attributes.doSetAttr(follicle[0],'parameterU',uv[0])
attributes.doSetAttr(follicle[0],'parameterV',uv[1])
try:mc.delete(o)
except:pass
else:
for o in self.createdList:
try:mc.delete(o)
except:pass
if self.createMode == 'curve' and len(self.returnList)>1:
if len(self.returnList) > 1:
self.createdList = [curves.curveFromPosList(self.returnList)]
else:
guiFactory.warning("Need at least 2 points for a curve")
elif self.createMode == 'jointChain':
self.createdList = []
mc.select(cl=True)
for pos in self.returnList:
self.createdList.append( mc.joint (p = (pos[0], pos[1], pos[2]),radius = 1) )
self.reset()
def returnObjectsConnectedToObj(obj,messageOnly = False):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for finding objects connected to another object
ARGUMENTS:
obj(string)
messageOnly(bool) - whether you only want mesage objects or not
RETURNS:
objList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
plugs = mc.listConnections(obj,p=True)
returnList = []
if plugs:
for o in plugs:
buffer = o.split('.')
if messageOnly:
if '[' not in buffer[-1]:
if attributes.queryIfMessage(buffer[0],buffer[-1]):
returnList.append(buffer[0])
else:
returnList.append(buffer[0])
return lists.returnListNoDuplicates(returnList)
else:
return False
def returnDrivenJoints(driverAttribute):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns driven objects from a driver Attribute
ARGUMENTS:
obj(string)
attr(string)
RETURNS:
attrInfo(varies)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
drivenJoints = []
attrConnections = mc.listConnections(driverAttribute, scn = True, s = False, t = 'animCurve')
if attrConnections:
for animCurve in attrConnections:
drivenJoint = search.seekDownStream(animCurve,'joint')
if mc.objExists(drivenJoint):
drivenJoints.append(drivenJoint)
drivenJoints = lists.returnListNoDuplicates(drivenJoints)
return drivenJoints
else:
guiFactory.warning('No anim curves found to be connected')
return False
"""
def returnObjectsConnectedToObj(obj,messageOnly = False):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for finding objects connected to another object
ARGUMENTS:
obj(string)
messageOnly(bool) - whether you only want mesage objects or not
RETURNS:
objList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
plugs = mc.listConnections(obj,p=True)
returnList = []
if plugs:
for o in plugs:
buffer = o.split('.')
if messageOnly:
if '[' not in buffer[-1]:
if attributes.queryIfMessage(buffer[0],buffer[-1]):
returnList.append(buffer[0])
else:
returnList.append(buffer[0])
return lists.returnListNoDuplicates(returnList)
else:
return False
def getSelectedCubeyRigNameSpaces():
selection = mc.ls(sl=True) or []
nameSpaces = []
for o in selection:
nameSpaces.append(search.returnReferencePrefix(o))
return lists.returnListNoDuplicates(nameSpaces)
def getSelectedCubeyRigNameSpaces():
selection = mc.ls(sl=True) or []
nameSpaces = []
for o in selection:
nameSpaces.append( search.returnReferencePrefix(o) )
return lists.returnListNoDuplicates(nameSpaces)
def returnObjectDrivenConstraints(obj):
"""
Returns constraints that this object is a target of
"""
constraintsBuffer = mc.listConnections(obj,source = False,destination = True,skipConversionNodes = True, type='constraint') or []
constraintsBuffer = lists.returnListNoDuplicates(constraintsBuffer)
objectConstraints = returnObjectConstraints(obj)
for c in objectConstraints:
if c in constraintsBuffer:constraintsBuffer.remove(c)
return constraintsBuffer
def existCheck(self):
"""
Attempts to select the items of a optionVar buffer
"""
bufferList = self.value
existsList = []
if bufferList:
for item in bufferList:
if mc.objExists(item):
existsList.append(item)
mc.optionVar(clearArray = self.name)
if existsList:
existsList = lists.returnListNoDuplicates(existsList)
self.extend(existsList)
def returnObjectDrivenConstraints(obj):
"""
Returns constraints that this object is a target of
"""
constraintsBuffer = mc.listConnections(obj,
source=False,
destination=True,
skipConversionNodes=True,
type='constraint') or []
constraintsBuffer = lists.returnListNoDuplicates(constraintsBuffer)
objectConstraints = returnObjectConstraints(obj)
for c in objectConstraints:
if c in constraintsBuffer: constraintsBuffer.remove(c)
return constraintsBuffer
def returnBlendShapeNodeFromPoseBuffer(poseBuffer):
poseBufferAttributes = attributes.returnUserAttributes(poseBuffer)
drivenObjects = []
if poseBufferAttributes:
for attr in poseBufferAttributes:
try:
buffer = attributes.returnDrivenObject(poseBuffer+'.'+attr)
if search.returnObjectType(buffer) == 'blendShape':
drivenObjects.append(buffer)
except:
pass
drivenObjects = lists.returnListNoDuplicates(drivenObjects)
return drivenObjects
else:
guiFactory.warning("No blendshape node connected to %s found" %poseBuffer)
return False
def returnEdgeLoopFromEdge(polyEdge):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns an edgeloop from an edge
ARGUMENTS:
polyEdge(string)
RETURNS:
edgeList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
splitBuffer = polyEdge.split('.')
polyObj = splitBuffer[0]
edges = mc.polySelect([polyObj],edgeLoop = (returnIndiceFromName(polyEdge)))
mc.select(cl=True)
edges = lists.returnListNoDuplicates(edges)
returnList = []
for edge in edges:
returnList.append('%s%s%i%s' %(polyObj,'.e[',edge,']'))
return returnList
def returnEdgeLoopFromEdge(polyEdge):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns an edgeloop from an edge
ARGUMENTS:
polyEdge(string)
RETURNS:
edgeList(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
splitBuffer = polyEdge.split('.')
polyObj = splitBuffer[0]
edges = mc.polySelect([polyObj],edgeLoop = (returnIndiceFromName(polyEdge)))
mc.select(cl=True)
edges = lists.returnListNoDuplicates(edges)
returnList = []
for edge in edges:
returnList.append('%s%s%i%s' %(polyObj,'.e[',edge,']'))
return returnList
lBuffer_attrOptions = []
tmpMenu = mUI.MelMenuItem( iTmpObjectSub, l="Change %s"%a, subMenu=True)
v = mc.getAttr("%s.%s"%(i_o.mNode,a))
for i,o in enumerate(cgmMeta.cgmAttr(i_o.mNode,a).p_enum):
if i == v:b_enable = False
else:b_enable = True
mUI.MelMenuItem(tmpMenu,l = "%s"%o,en = b_enable,
c = cgmUI.Callback(mi_dynParent.doSwitchSpace,a,i))
else:
log.debug("'%s':lacks dynParent"%i_o.getShortName())
#>>> Module =====================================================================================================
timeStart_ModuleStuff = time.clock()
if self.BuildModuleOptionVar.value and self.ml_modules:
#MelMenuItem(parent,l="-- Modules --",en = False)
self.ml_modules = lists.returnListNoDuplicates(self.ml_modules)
int_lenModules = len(self.ml_modules)
if int_lenModules == 1:
use_parent = parent
state_multiModule = False
else:
iSubM_modules = mUI.MelMenuItem(parent,l="Modules(%s)"%(int_lenModules),subMenu = True)
use_parent = iSubM_modules
state_multiModule = True
mUI.MelMenuItem( parent, l="Select",
c = cgmUI.Callback(func_multiModuleSelect))
mUI.MelMenuItem( parent, l="Key",
c = cgmUI.Callback(func_multiModuleKey))
mUI.MelMenuItem( parent, l="toFK",
c = cgmUI.Callback(func_multiDynSwitch,0))
mUI.MelMenuItem( parent, l="toIK",
def _create(self):
mi_base = self.mi_baseCurve
mi_target = self.mi_targetCurve
self.l_baseCvPos = []
self.d_base = self.getCurveMirrorData(mi_base)
if not mi_target:#if no target, mirror self
if not self.d_base['b_oneSided']:
if self.d_base['b_even']:
log.info("%s Even mirror"%self._str_reportStart)
l_cvPos = self.d_base['l_cvPos']
l_cvs = self.d_base['l_cvs']
int_split = int(len(l_cvPos)/2)
log.info(int_split)
l_splitDriven = l_cvs[int_split:]
l_splitDriver = l_cvs[:int_split]
l_splitDriverPos = l_cvPos[:int_split]
l_splitDriverPos.reverse()
log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven))
log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver))
for i,cv in enumerate(l_splitDriven):
pos = l_splitDriverPos[i]
mc.move(-pos[0],pos[1],pos[2], cv, ws=True)
return True
else:
log.info("%s nonEven mirror"%self._str_reportStart)
l_cvPos = self.d_base['l_cvPos']
l_cvs = self.d_base['l_cvs']
int_split = int(len(l_cvPos)/2)
l_cvPos.pop(int_split)
l_cvs.pop(int_split)
l_splitDriven = l_cvs[int_split:]
l_splitDriver = l_cvs[:int_split]
l_splitDriverPos = l_cvPos[:int_split]
l_splitDriverPos.reverse()
log.info("%s l_splitDriven: %s"%(self._str_reportStart,l_splitDriven))
log.info("%s l_splitDriver: %s"%(self._str_reportStart,l_splitDriver))
for i,cv in enumerate(l_splitDriven):
pos = l_splitDriverPos[i]
mc.move(-pos[0],pos[1],pos[2], cv, ws=True)
return True
else:#it's one sided
log.info("%s Build other side. New crv"%self._str_reportStart)
l_epPos = self.d_base['l_epPos']
l_otherSide = copy.copy(l_epPos)
l_otherSide.reverse()
for i,pos in enumerate(l_otherSide):
l_otherSide[i] = [-pos[0],pos[1],pos[2]]
#l_newCurvePos = l_epPos + l_otherSide
l_newCurvePos = l_otherSide
l_newCurvePos = lists.returnListNoDuplicates(l_newCurvePos)
self.mi_created = cgmMeta.cgmObject( mc.curve(d=2,p=l_newCurvePos,os = True) )
self.mi_created.rename( mi_base.p_nameBase + '_mirrored')
#
if self.d_base['b_startInThreshold'] or self.d_base['b_endInThreshold']:
#In this case we need to combine and rebuild the curve
try:
str_attachedCurves = mc.attachCurve([self.mi_created.mNode,self.mi_baseCurve.mNode],
blendBias = self.d_kws['blendBias'])
except Exception,error:raise StandardError,"Attach curve | %s"%error
#mc.delete(self.mi_created.mNode)#delete the old one
#self.mi_created = cgmMeta.cgmObject(str_attachedCurves[0])
#int_spans = (len(l_epPos)*1.5)
int_spans = len(l_epPos)+1
try:
mc.rebuildCurve (self.mi_created.mNode, ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=int_spans, d=3, tol=0.001)
except Exception,error:raise StandardError,"Rebuild curve | %s"%error
try:
mc.reverseCurve (self.mi_created.mNode, rpo=1)
except Exception,error:raise StandardError,"Reverse curve | %s"%error
self.mi_created.rename( mi_base.p_nameBase + '_mirrored')
return self.mi_created.p_nameShort
#See if we need to make new curve to have stuff to mirror
else:#if we have a target
self.d_target = self.getCurveMirrorData(mi_target)
l_cvsBase = self.d_base['l_cvs']
l_cvsTarget = self.d_target['l_cvs']
if len(l_cvsBase) != len(l_cvsTarget):
raise NotImplementedError,"Haven't added ability to do curves of differing cv lengths yet"
for i,pos in enumerate(self.d_base['l_cvPos']):
mc.move(-pos[0],pos[1],pos[2], l_cvsTarget[i], ws=True)
return True
def returnOrderedChildrenModules(moduleNull):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns children parts organized by part type and direction
ARGUMENTS:
moduleNull(string)
RETURNS:
returnDict(dict) - {type:{direction:['1','2'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
modules = returnSceneModules()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Info gathering
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
moduleParents = {}
for module in modules:
moduleParents[module] = attributes.returnMessageObject(
module, 'moduleParent')
print moduleParents
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Parsing out Children
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
childrenModules = []
""" first we're gonna find all modules that have our module as it's parent"""
for key in moduleParents.keys():
if moduleParents.get(key) == moduleNull:
childrenModules.append(key)
print childrenModules
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Further parsing
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
moduleTypes = {}
typesPresent = []
""" first get the types and a simplified types present list """
for module in childrenModules:
isType = search.returnTagInfo(module, 'cgmModuleType')
typesPresent.append(isType)
moduleTypes[module] = isType
typesPresent = lists.returnListNoDuplicates(typesPresent)
""" get the data together for return """
moduleDirectionalInfo = {}
directionsPresent = []
for module in childrenModules:
isDirection = returnDirectionalInfoToString(module)
directionsPresent.append(isDirection)
moduleDirectionalInfo[module] = isDirection
directionsPresent = lists.returnListNoDuplicates(directionsPresent)
returnDict = {}
for t in typesPresent:
tagBuffer = {}
for d in directionsPresent:
dBuffer = []
for module in childrenModules:
if moduleTypes.get(module) == t:
if moduleDirectionalInfo.get(module) == d:
dBuffer.append(module)
if len(dBuffer) > 0:
tagBuffer[d] = dBuffer
returnDict[t] = tagBuffer
if len(returnDict) > 0:
return returnDict
else:
return False
rigUtils.controlCurveTightenEndWeights('test_splineIKCurve','driverBase','driverTop',3)
rigUtils.createControlSurfaceSegment(jointList,secondaryAxis='zdown')
rigUtils.addRibbonTwistToControlSurfaceSetup(jointList,'spine_1_influenceJoint.rotateZ','sternum_influenceJoint.rotateZ')
rigUtils.addSquashAndStretchToControlSurfaceSetup('test_distanceBuffer',jointList,orientation = 'zyx')
rigUtils.addRibbonTwistToControlSurfaceSetup(jointList,['spine_1_influenceJoint','rotateZ'],['sternum_influenceJoint','rotateZ'])
addSquashAndStretchToControlSurfaceSetup(attributeHolder,jointList,orientation = 'zyx', moduleInstance = None):
rigUtils.addRibbonTwistToControlSurfaceSetup(jointList,startControlDriver = ['driverBase','rz'], endControlDriver = ['driverTop','rz'],rotateGroupAxis = 'rotateZ',orientation = 'zyx', moduleInstance = None)
#>>> Smooth skin weights on surface
rigUtils.controlSurfaceSmoothWeights('test_controlSurface',start = 'spine_1_influenceJoint', end = 'sternum_influenceJoint', blendLength = 5)
cgmMeta.cgmObject('test_controlSurface').getComponents('cv')
test = [u'test_controlSurface.cv[0][0]', u'test_controlSurface.cv[0][1]', u'test_controlSurface.cv[0][2]', u'test_controlSurface.cv[0][3]', u'test_controlSurface.cv[0][4]', u'test_controlSurface.cv[0][5]', u'test_controlSurface.cv[0][6]', u'test_controlSurface.cv[1][0]', u'test_controlSurface.cv[1][1]', u'test_controlSurface.cv[1][2]', u'test_controlSurface.cv[1][3]', u'test_controlSurface.cv[1][4]', u'test_controlSurface.cv[1][5]', u'test_controlSurface.cv[1][6]'] #
cvStarts = [int(obj[-5]) for obj in test]
cvEnds = [int(obj[-2]) for obj in test]
from cgm.lib import lists
cvStarts = lists.returnListNoDuplicates(cvStarts)
cvEnds = lists.returnListNoDuplicates(cvEnds)
log.info(cvStarts)
log.info(cvEnds)
cgmMeta.cgmObject(mc.ls(sl=True)[0],ud = True).compareAttrs(mc.ls(sl=True)[1])
#Can't find difference in to
#Joint attach:
from cgm.lib import joints
reload(joints)
joints.attachJointChainToSurface(jointList,'loftedSurface1','zyx','yup')
joints.loftSurfaceFromJointList(jointList,'x')
def returnOrderedChildrenModules(moduleNull):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns children parts organized by part type and direction
ARGUMENTS:
moduleNull(string)
RETURNS:
returnDict(dict) - {type:{direction:['1','2'
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
modules = returnSceneModules()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Info gathering
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
moduleParents ={}
for module in modules:
moduleParents[module] = attributes.returnMessageObject(module,'moduleParent')
print moduleParents
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Parsing out Children
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
childrenModules = []
""" first we're gonna find all modules that have our module as it's parent"""
for key in moduleParents.keys():
if moduleParents.get(key) == moduleNull:
childrenModules.append(key)
print childrenModules
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Further parsing
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
moduleTypes = {}
typesPresent = []
""" first get the types and a simplified types present list """
for module in childrenModules:
isType = search.returnTagInfo(module,'cgmModuleType')
typesPresent.append(isType)
moduleTypes[module] = isType
typesPresent = lists.returnListNoDuplicates(typesPresent)
""" get the data together for return """
moduleDirectionalInfo = {}
directionsPresent = []
for module in childrenModules:
isDirection = returnDirectionalInfoToString(module)
directionsPresent.append(isDirection)
moduleDirectionalInfo[module] = isDirection
directionsPresent = lists.returnListNoDuplicates(directionsPresent)
returnDict = {}
for t in typesPresent:
tagBuffer = {}
for d in directionsPresent:
dBuffer = []
for module in childrenModules:
if moduleTypes.get(module) == t:
if moduleDirectionalInfo.get(module) == d:
dBuffer.append(module)
if len(dBuffer) > 0:
tagBuffer[d] = dBuffer
returnDict[t] = tagBuffer
if len(returnDict) > 0:
return returnDict
else:
return False
lBuffer_attrOptions = []
tmpMenu = MelMenuItem( iTmpObjectSub, l="Change %s"%a, subMenu=True)
v = mc.getAttr("%s.%s"%(i_o.mNode,a))
for i,o in enumerate(cgmMeta.cgmAttr(i_o.mNode,a).p_enum):
if i == v:b_enable = False
else:b_enable = True
MelMenuItem(tmpMenu,l = "%s"%o,en = b_enable,
c = Callback(mi_dynParent.doSwitchSpace,a,i))
else:
log.debug("'%s':lacks dynParent"%i_o.getShortName())
#>>> Module =====================================================================================================
timeStart_ModuleStuff = time.clock()
if self.BuildModuleOptionVar.value and self.ml_modules:
#MelMenuItem(parent,l="-- Modules --",en = False)
self.ml_modules = lists.returnListNoDuplicates(self.ml_modules)
int_lenModules = len(self.ml_modules)
if int_lenModules == 1:
use_parent = parent
state_multiModule = False
else:
iSubM_modules = MelMenuItem(parent,l="Modules(%s)"%(int_lenModules),subMenu = True)
use_parent = iSubM_modules
state_multiModule = True
MelMenuItem( parent, l="Select",
c = Callback(func_multiModuleSelect))
MelMenuItem( parent, l="Key",
c = Callback(func_multiModuleKey))
MelMenuItem( parent, l="toFK",
c = Callback(func_multiDynSwitch,0))
MelMenuItem( parent, l="toIK",
def returnObjectConstraints(object):
buffer = mc.listRelatives(object,type='constraint',fullPath=True) or []
if buffer:return lists.returnListNoDuplicates(buffer)
else:
log.debug('%s has no constraints' %object)
return []
def get_key_indices_from(node=None, mode='all'):
"""
Return a list of the time indexes of the keyframes on an object
:parameters:
node(str): What you want to get the keys of
mode(str):
all -- Every key
next --
previous --
forward --
back --
bookEnd -- previous/next
selected - from selected range
:returns
list of keys(list)
"""
_str_func = 'get_key_indices'
if not ATTR.get_keyed(node):
return []
initialTimeState = mc.currentTime(q=True)
keyFrames = []
if mode == 'next':
_key = mc.findKeyframe(node, which='next', an='objects')
if _key > initialTimeState:
return [_key]
return []
elif mode == 'forward':
lastKey = mc.findKeyframe(node, which='last', an='objects')
keyCheck = [lastKey]
rangeCheck = [initialTimeState - 1, lastKey]
_i = 0
while mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0],
rangeCheck[1])) not in keyCheck:
#if _i>100:break
_key = mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0], rangeCheck[1]))
keyFrames.append(_key)
if rangeCheck[0] == _key: break
rangeCheck[0] = _key
#print "{0} | {1}".format(rangeCheck,_key)
_i += 1
"""
mc.currentTime(initialTimeState-1)
while mc.currentTime(q=True) != lastKey:
keyBuffer = mc.findKeyframe(node,which = 'next',an='objects')
if keyBuffer > initialTimeState:
keyFrames.append(keyBuffer)
mc.currentTime(keyBuffer)"""
if lastKey > initialTimeState:
keyFrames.append(lastKey)
elif mode == 'bookEnd':
_prev = mc.findKeyframe(node, which='previous', an='objects')
_next = mc.findKeyframe(node, which='next', an='objects')
_current = initialTimeState
if _next and _next > initialTimeState:
_l = [_prev, _next]
_currentKeyQuery = mc.findKeyframe(node,
which='next',
an='objects',
time=(_prev, _next))
if _currentKeyQuery:
_l.insert(1, _currentKeyQuery)
return _l
elif mode == 'previous':
_key = mc.findKeyframe(node, which='previous', an='objects')
#mc.currentTime(initialTimeState-1)
if _key:
return [_key]
return []
elif mode in ['back']:
firstKey = mc.findKeyframe(node, which='first', an='objects')
keyCheck = [firstKey]
rangeCheck = [firstKey, initialTimeState]
_i = 0
keyFrames.append(firstKey)
while mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0],
rangeCheck[1])) not in keyCheck:
#if _i>100:break
_key = mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0], rangeCheck[1]))
if _key > initialTimeState: break
if rangeCheck[0] == _key: break
keyFrames.append(_key)
rangeCheck[0] = _key
#print "{0} | {1}".format(rangeCheck,_key)
_i += 1
"""
firstKey = mc.findKeyframe(node,which = 'first',an='objects')
lastKey = mc.findKeyframe(node,which = 'last',an='objects')
mc.currentTime(firstKey-1)
while mc.currentTime(q=True) != lastKey:
if mc.currentTime(q=True) >= initialTimeState:
log.debug('higher: {0}'.format(mc.currentTime(q=True)))
break
keyBuffer = mc.findKeyframe(node,which = 'next',an='objects')
if keyBuffer < initialTimeState:
keyFrames.append(keyBuffer)
#log.debug(keyFrames)
mc.currentTime(keyBuffer)
else:
break"""
if mode == 'previous' and keyFrames:
keyFrames = [keyFrames[-1]]
elif mode in ['all', 'selected', 'slider']:
firstKey = mc.findKeyframe(node, which='first', an='objects')
lastKey = mc.findKeyframe(node, which='last', an='objects')
keyCheck = [firstKey]
rangeCheck = [firstKey, lastKey]
_i = 0
keyFrames.append(firstKey)
while mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0],
rangeCheck[1])) not in keyCheck:
#if _i>100:break
_key = mc.findKeyframe(node,
which='next',
an='objects',
time=(rangeCheck[0], rangeCheck[1]))
if _key > lastKey:
break
keyFrames.append(_key)
if rangeCheck[0] == _key: break
rangeCheck[0] = _key
#print "{0} | {1}".format(rangeCheck,_key)
_i += 1
"""
keyFrames.append(firstKey)
mc.currentTime(firstKey-1)
while mc.currentTime(q=True) != lastKey:
keyBuffer = mc.findKeyframe(node,which = 'next',an='objects')
keyFrames.append(keyBuffer)
mc.currentTime(keyBuffer)
keyFrames.append(lastKey)"""
# Put the time back where we found it
#mc.currentTime(initialTimeState)
if mode in ['selected', 'slider']:
_range = get_time(mode)
if not _range:
return False
_l_cull = []
for k in keyFrames:
if k > (_range[0] - 1) and k < (_range[1] + 1):
_l_cull.append(k)
keyFrames = _l_cull
else:
raise ValueError, "Unknown mode: {0}".format(mode)
#mc.currentTime(initialTimeState)
return lists.returnListNoDuplicates(keyFrames)
def returnObjectConstraints(object):
buffer = mc.listRelatives(object, type='constraint', fullPath=True) or []
if buffer: return lists.returnListNoDuplicates(buffer)
else:
log.debug('%s has no constraints' % object)
return []
