def updateBufferName(self,bufferTextField,bufferName):
newName = mc.textField(bufferTextField,q=True,text = True)
assert mc.objExists(bufferName) is True,"'%s' doesn't exist.Try updating the tool."%bufferObject
if bufferName and newName:
b = ObjectFactory(bufferName)
b.store('cgmName', newName)
b.doName()
mc.textField(bufferTextField,e = True,text = b.nameBase)
#Reset
guiFactory.resetGuiInstanceOptionVars(self.optionVars,bufferTools.run)
else:
guiFactory.warning("There's a problem with the name input.")
def __init__(self, obj='', makeAimable=True, controlRO=False):
"""
Asserts objects existance and that it has a transform. Then initializes.
Keyword arguments:
obj(string)
makeAimable(bool) -- whether to set up aim controls
"""
self.aimable = False
self.stateControlRO = False
### input check
ObjectFactory.__init__(self, obj=obj)
if makeAimable or mc.objExists("%s.%s" % (self.nameLong, 'axisAim')):
self.verifyAimControls()
if controlRO or mc.objExists("%s.%s" % (self.nameLong, 'setRo')):
self.verifyRotateOrderControl()
def __init__(self,obj='',makeAimable = True, controlRO = False):
"""
Asserts objects existance and that it has a transform. Then initializes.
Keyword arguments:
obj(string)
makeAimable(bool) -- whether to set up aim controls
"""
self.aimable = False
self.stateControlRO = False
### input check
ObjectFactory.__init__(self,obj=obj)
if makeAimable or mc.objExists("%s.%s"%(self.nameLong,'axisAim')):
self.verifyAimControls()
if controlRO or mc.objExists("%s.%s"%(self.nameLong,'setRo')):
self.verifyRotateOrderControl()
def updateBufferName(self,bufferTextField,bufferName):
newName = mc.textField(bufferTextField,q=True,text = True)
assert mc.objExists(bufferName) is True,"'%s' doesn't exist.Try updating the tool."%bufferObject
if bufferName and newName:
b = ObjectFactory(bufferName)
b.store('cgmName', newName)
b.doName()
mc.textField(bufferTextField,e = True,text = b.nameBase)
#Reset
guiFactory.resetGuiInstanceOptionVars(self.optionVars,bufferTools.run)
else:
guiFactory.warning("There's a problem with the name input.")
def __init__(self,
objName,
attrName,
attrType=False,
value=None,
enum=False,
initialValue=None,
lock=None,
keyable=None,
hidden=None,
*a,
**kw):
"""
Asserts object's existance and that it has a transform. Then initializes. If
an existing attribute name on an object is called and the attribute type is different,it converts it. All functions
ignore locks on attributes and will act when called regardless of target settings
Keyword arguments:
obj(string) -- must exist in scene or an ObjectFactory instance
attrName(string) -- name for an attribute to initialize
attrType(string) -- must be valid attribute type. If AttrFactory is imported, you can type 'print attrTypesDict'
enum(string) -- default enum list to set on call or recall
value() -- set value on call
initialValue() -- only set on creation
*a, **kw
"""
### input check
try:
#If we have an Object Factory instance, link it
objName.nameShort
self.obj = objName
except:
#If it fails, check that the object name exists and if so, initialize a new Object Factory instance
assert mc.objExists(
objName) is True, "'%s' doesn't exist" % objName
self.obj = ObjectFactory(objName)
self.form = attributes.validateRequestedAttrType(attrType)
self.attr = attrName
self.children = False
initialCreate = False
# If it exists we need to check the type.
if mc.objExists('%s.%s' % (self.obj.nameShort, attrName)):
currentType = mc.getAttr('%s.%s' % (self.obj.nameShort, attrName),
type=True)
if not attributes.validateAttrTypeMatch(
attrType, currentType) and self.form is not False:
if self.obj.refState:
return guiFactory.warning(
"'%s' is referenced. cannot convert '%s' to '%s'!" %
(self.obj.nameShort, attrName, attrType))
self.doConvert(attrType)
else:
self.attr = attrName
self.form = currentType
else:
try:
if self.form == False:
self.form = 'string'
attributes.addStringAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'double':
attributes.addFloatAttributeToObject(
self.obj.nameShort, attrName, *a, **kw)
elif self.form == 'string':
attributes.addStringAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'long':
attributes.addIntegerAttributeToObj(
self.obj.nameShort, attrName, *a, **kw)
elif self.form == 'double3':
attributes.addVectorAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'enum':
attributes.addEnumAttrToObj(self.obj.nameShort, attrName,
*a, **kw)
elif self.form == 'bool':
attributes.addBoolAttrToObject(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'message':
attributes.addMessageAttributeToObj(
self.obj.nameShort, attrName, *a, **kw)
else:
guiFactory.warning(
"'%s' is an unknown form to this class" % (self.form))
return False
initialCreate = True
except:
guiFactory.warning("'%s.%s' failed to add" %
(self.obj.nameShort, attrName))
self.updateData(*a, **kw)
if enum:
try:
self.setEnum(enum)
except:
guiFactory.warning("Failed to set enum value of '%s'" % enum)
if initialValue is not None and initialCreate:
self.set(initialValue)
elif value is not None:
self.set(value)
if type(keyable) is bool:
self.doKeyable(keyable)
if type(hidden) is bool:
self.doHidden(hidden)
if type(lock) is bool:
self.doLocked(lock)
class AttrFactory():
"""
Initialized a maya attribute as a class obj
"""
def __init__(self,
objName,
attrName,
attrType=False,
value=None,
enum=False,
initialValue=None,
lock=None,
keyable=None,
hidden=None,
*a,
**kw):
"""
Asserts object's existance and that it has a transform. Then initializes. If
an existing attribute name on an object is called and the attribute type is different,it converts it. All functions
ignore locks on attributes and will act when called regardless of target settings
Keyword arguments:
obj(string) -- must exist in scene or an ObjectFactory instance
attrName(string) -- name for an attribute to initialize
attrType(string) -- must be valid attribute type. If AttrFactory is imported, you can type 'print attrTypesDict'
enum(string) -- default enum list to set on call or recall
value() -- set value on call
initialValue() -- only set on creation
*a, **kw
"""
### input check
try:
#If we have an Object Factory instance, link it
objName.nameShort
self.obj = objName
except:
#If it fails, check that the object name exists and if so, initialize a new Object Factory instance
assert mc.objExists(
objName) is True, "'%s' doesn't exist" % objName
self.obj = ObjectFactory(objName)
self.form = attributes.validateRequestedAttrType(attrType)
self.attr = attrName
self.children = False
initialCreate = False
# If it exists we need to check the type.
if mc.objExists('%s.%s' % (self.obj.nameShort, attrName)):
currentType = mc.getAttr('%s.%s' % (self.obj.nameShort, attrName),
type=True)
if not attributes.validateAttrTypeMatch(
attrType, currentType) and self.form is not False:
if self.obj.refState:
return guiFactory.warning(
"'%s' is referenced. cannot convert '%s' to '%s'!" %
(self.obj.nameShort, attrName, attrType))
self.doConvert(attrType)
else:
self.attr = attrName
self.form = currentType
else:
try:
if self.form == False:
self.form = 'string'
attributes.addStringAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'double':
attributes.addFloatAttributeToObject(
self.obj.nameShort, attrName, *a, **kw)
elif self.form == 'string':
attributes.addStringAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'long':
attributes.addIntegerAttributeToObj(
self.obj.nameShort, attrName, *a, **kw)
elif self.form == 'double3':
attributes.addVectorAttributeToObj(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'enum':
attributes.addEnumAttrToObj(self.obj.nameShort, attrName,
*a, **kw)
elif self.form == 'bool':
attributes.addBoolAttrToObject(self.obj.nameShort,
attrName, *a, **kw)
elif self.form == 'message':
attributes.addMessageAttributeToObj(
self.obj.nameShort, attrName, *a, **kw)
else:
guiFactory.warning(
"'%s' is an unknown form to this class" % (self.form))
return False
initialCreate = True
except:
guiFactory.warning("'%s.%s' failed to add" %
(self.obj.nameShort, attrName))
self.updateData(*a, **kw)
if enum:
try:
self.setEnum(enum)
except:
guiFactory.warning("Failed to set enum value of '%s'" % enum)
if initialValue is not None and initialCreate:
self.set(initialValue)
elif value is not None:
self.set(value)
if type(keyable) is bool:
self.doKeyable(keyable)
if type(hidden) is bool:
self.doHidden(hidden)
if type(lock) is bool:
self.doLocked(lock)
#guiFactory.report("'%s.%s' >> '%s' >> is '%s'"%(self.obj.nameShort,self.attr,self.value,self.form))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Base Functions
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def updateData(self, *a, **kw):
"""
Get's attr updated data
"""
assert mc.objExists(
'%s.%s' % (self.obj.nameShort, self.attr)
) is True, "'%s.%s' doesn't exist" % (self.obj.nameShort, self.attr)
# Default attrs
self.nameCombined = '%s.%s' % (self.obj.nameShort, self.attr)
self.minValue = False
self.maxValue = False
self.defaultValue = False
self.nameNice = mc.attributeQuery(self.attr,
node=self.obj.nameShort,
niceName=True)
self.nameLong = mc.attributeQuery(self.attr,
node=self.obj.nameShort,
longName=True)
self.nameAlias = False
if mc.aliasAttr(self.nameCombined, q=True):
self.nameAlias = mc.aliasAttr(self.nameCombined, q=True)
self.get(*a, **kw)
#>>> Parent Stuff
pBuffer = mc.attributeQuery(self.attr,
node=self.obj.nameShort,
listParent=True)
if pBuffer is None:
self.parent = False
else:
self.parent = pBuffer[0]
self.children = mc.attributeQuery(self.attr,
node=self.obj.nameShort,
listChildren=True)
if self.children is None:
self.children = False
self.siblings = mc.attributeQuery(self.attr,
node=self.obj.nameShort,
listSiblings=True)
if self.siblings is None:
self.siblings = False
self.enum = False
self.userAttrs = mc.listAttr(self.obj.nameShort,
userDefined=True) or []
standardFlagsBuffer = attributes.returnStandardAttrFlags(
self.obj.nameShort, self.nameLong)
standardDataBuffer = attributes.returnAttributeDataDict(
self.obj.nameShort, self.nameLong)
#Check connections
self.driver = attributes.returnDriverAttribute(self.nameCombined,
False)
self.driven = attributes.returnDrivenAttribute(self.nameCombined,
False)
self.numeric = standardFlagsBuffer.get('numeric')
self.dynamic = standardFlagsBuffer.get('dynamic')
self.locked = standardFlagsBuffer.get('locked')
self.keyable = standardFlagsBuffer.get('keyable')
self.hidden = standardFlagsBuffer.get('hidden')
if self.dynamic:
self.readable = standardFlagsBuffer.get('readable')
self.writable = standardFlagsBuffer.get('writable')
self.storable = standardFlagsBuffer.get('storable')
self.usedAsColor = standardFlagsBuffer.get('usedAsColor')
#>>> Numeric
if self.numeric:
bufferDict = attributes.returnNumericAttrSettingsDict(
self.obj.nameShort, self.nameLong)
if bufferDict:
self.maxValue = bufferDict.get('max')
self.minValue = bufferDict.get('min')
self.defaultValue = bufferDict.get('default')
self.softMaxValue = bufferDict.get('softMax')
self.softMinValue = bufferDict.get('softMin')
self.rangeValue = bufferDict.get('range')
self.softRangeValue = bufferDict.get('softRange')
else:
self.maxValue = False
self.minValue = False
self.defaultValue = False
self.softMaxValue = False
self.softMinValue = False
self.rangeValue = False
self.softRangeValue = False
if self.form == 'enum':
self.enum = standardFlagsBuffer.get('enum')
def doConvert(self, attrType):
"""
Converts an attribute type from one to another while preserving as much data as possible.
Keyword arguments:
attrType(string)
"""
self.updateData()
if self.obj.refState:
return guiFactory.warning(
"'%s' is referenced. cannot convert '%s' to '%s'!" %
(self.obj.nameShort, self.attr, attrType))
if self.children:
return guiFactory.warning("'%s' has children, can't convert" %
self.nameCombined)
keyable = copy.copy(self.keyable)
hidden = copy.copy(self.hidden)
locked = copy.copy(self.locked)
storedNumeric = False
if self.numeric and not self.children:
storedNumeric = True
minimum = copy.copy(self.minValue)
maximum = copy.copy(self.maxValue)
default = copy.copy(self.defaultValue)
softMin = copy.copy(self.softMinValue)
softMax = copy.copy(self.softMaxValue)
attributes.doConvertAttrType(self.nameCombined, attrType)
self.updateData()
#>>> Reset variables
self.doHidden(hidden)
self.doKeyable(keyable)
self.doLocked(locked)
if self.numeric and not self.children and storedNumeric:
if softMin is not False or int(softMin) != 0:
self.doSoftMin(softMin)
if softMax is not False or int(softMax) != 0:
self.doSoftMax(softMax)
if minimum is not False:
self.doMin(minimum)
if maximum is not False:
self.doMax(maximum)
if default is not False:
self.doDefault(default)
guiFactory.warning("'%s.%s' converted to '%s'" %
(self.obj.nameShort, self.attr, attrType))
"""except:
guiFactory.warning("'%s.%s' failed to convert"%(self.obj.nameShort,self.attr))"""
def set(self, value, *a, **kw):
"""
Set attr value based on attr type
Keyword arguments:
value(varied)
*a, **kw
"""
try:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for i, c in enumerate(self.children):
try:
cInstance = AttrFactory(self.obj.nameShort, c)
if type(value) is list and len(self.children) == len(
value
): #if we have the same length of values in our list as we have children, use them
attributes.doSetAttr(cInstance.obj.nameShort,
cInstance.attr, value[i], *a,
**kw)
cInstance.value = value[i]
self.value = value
else:
attributes.doSetAttr(cInstance.obj.nameShort,
cInstance.attr, value, *a,
**kw)
self.value = value
except:
guiFactory.warning("'%s' failed to set" % c)
elif self.form == 'message':
if value:
self.doStore(value)
else:
attributes.doSetAttr(self.obj.nameShort, self.attr, value, *a,
**kw)
self.value = value
except:
guiFactory.warning("'%s.%s' failed to set '%s'" %
(self.obj.nameShort, self.attr, value))
def get(self, *a, **kw):
"""
Get and store attribute value based on attr type
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(
self.obj.nameShort, self.attr)
else:
self.value = attributes.doGetAttr(self.obj.nameShort,
self.attr)
#guiFactory.report("'%s.%s' >> '%s'"%(self.obj.nameShort,self.attr,self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get" %
(self.obj.nameShort, self.attr))
def getMessage(self, *a, **kw):
"""
Get and store attribute value as if they were messages. Used for bufferFactory to use a connected
attribute as a poor man's attribute message function
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(
self.obj.nameShort, self.attr)
if search.returnObjectType(self.value) == 'reference':
if attributes.repairMessageToReferencedTarget(
self.obj.nameLong, self.attr, *a, **kw):
self.value = attributes.returnMessageObject(
self.obj.nameShort, self.attr)
else:
self.value = attributes.returnDriverAttribute(
"%s.%s" % (self.obj.nameShort, self.attr))
guiFactory.report("'%s.%s' >Message> '%s'" %
(self.obj.nameShort, self.attr, self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get" %
(self.obj.nameShort, self.attr))
def setEnum(self, enumCommand):
"""
Set the options for an enum attribute
Keyword arguments:
enumCommand(string) -- 'off:on', 'off=0:on=2', etc
"""
try:
if self.form == 'enum':
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
at='enum',
en=enumCommand)
self.enum = enumCommand
guiFactory.report("'%s.%s' has been updated!" %
(self.obj.nameShort, self.attr))
else:
guiFactory.warning("'%s.%s' is not an enum. Invalid call" %
(self.obj.nameShort, self.attr))
except:
guiFactory.warning("'%s.%s' failed to change..." %
(self.obj.nameShort, self.attr))
def doStore(self, infoToStore, convertIfNecessary=True):
"""
Store information to an object. If the info exits as an object, it stores as a message node. Otherwise there are
other storing methods.
Keyword arguments:
infoToStore(string) -- string of information to store
convertIfNecessary(bool) -- whether to convert the attribute if it needs to to store it. Default (True)
"""
assert self.children is False, "This attribute has children. Can't store."
try:
if self.form == 'message':
self.obj.store(self.attr, infoToStore)
self.value = infoToStore
elif convertIfNecessary:
self.doConvert('message')
self.updateData()
self.obj.store(self.attr, infoToStore)
self.value = infoToStore
except:
guiFactory.warning("'%s.%s' failed to store '%s'" %
(self.obj.nameShort, self.attr, infoToStore))
def doDelete(self):
"""
Deletes an attribute
"""
try:
attributes.doDeleteAttr(self.obj.nameShort, self.attr)
guiFactory.warning("'%s.%s' deleted" %
(self.obj.nameShort, self.attr))
self.value = None
return self.value
except:
guiFactory.warning("'%s.%s' failed to delete" %
(self.obj.nameShort, self.attr))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Set Options
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def doDefault(self, value=None):
"""
Set default settings of an attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric:
if value is not None:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
try:
mc.addAttr((cInstance.obj.nameShort + '.' +
cInstance.attr),
e=True,
defaultValue=value)
cInstance.defaultValue = value
except:
guiFactory.warning(
"'%s' failed to set a default value" %
cInstance.nameCombined)
self.defaultValue = value
else:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
defaultValue=value)
self.defaultValue = value
except:
guiFactory.warning(
"'%s.%s' failed to set a default value" %
(self.obj.nameShort, self.attr))
def doMax(self, value=None):
"""
Set max value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
hasMaxValue=value)
self.maxValue = value
guiFactory.warning("'%s.%s' had it's max value cleared" %
(self.obj.nameShort, self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a max value" %
(self.obj.nameShort, self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
maxValue=value)
self.maxValue = value
except:
guiFactory.warning("'%s.%s' failed to set a max value" %
(self.obj.nameShort, self.attr))
def doMin(self, value=None):
"""
Set min value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
hasMinValue=value)
self.minValue = value
guiFactory.warning("'%s.%s' had it's min value cleared" %
(self.obj.nameShort, self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a min value" %
(self.obj.nameShort, self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
minValue=value)
self.minValue = value
except:
guiFactory.warning(
"'%s.%s' failed to set a default value" %
(self.obj.nameShort, self.attr))
def doSoftMax(self, value=None):
"""
Set soft max value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
hasSoftMaxValue=0)
self.softMaxValue = value
guiFactory.warning(
"'%s.%s' had it's soft max value cleared" %
(self.obj.nameShort, self.attr))
except:
guiFactory.warning(
"'%s.%s' failed to clear a soft max value" %
(self.obj.nameShort, self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
softMaxValue=value)
self.softMaxValue = value
except:
guiFactory.warning(
"'%s.%s' failed to set a soft max value" %
(self.obj.nameShort, self.attr))
def doSoftMin(self, value=None):
"""
Set soft min value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
hasSoftMinValue=0)
self.softMinValue = value
guiFactory.warning(
"'%s.%s' had it's soft max value cleared" %
(self.obj.nameShort, self.attr))
except:
guiFactory.warning(
"'%s.%s' failed to clear a soft max value" %
(self.obj.nameShort, self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort + '.' + self.attr),
e=True,
softMinValue=value)
self.softMinValue = value
except:
guiFactory.warning(
"'%s.%s' failed to set a soft max value" %
(self.obj.nameShort, self.attr))
def doLocked(self, arg=True):
"""
Set lock state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if not cInstance.locked:
mc.setAttr(
(cInstance.obj.nameShort + '.' + cInstance.attr),
e=True,
lock=True)
guiFactory.report(
"'%s.%s' locked!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.locked = True
self.updateData()
elif not self.locked:
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
lock=True)
guiFactory.report("'%s.%s' locked!" %
(self.obj.nameShort, self.attr))
self.locked = True
else:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if cInstance.locked:
mc.setAttr(
(cInstance.obj.nameShort + '.' + cInstance.attr),
e=True,
lock=False)
guiFactory.report(
"'%s.%s' unlocked!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.locked = False
self.updateData()
elif self.locked:
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
lock=False)
guiFactory.report("'%s.%s' unlocked!" %
(self.obj.nameShort, self.attr))
self.locked = False
def doHidden(self, arg=True):
"""
Set hidden state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if not cInstance.hidden:
if cInstance.keyable:
cInstance.doKeyable(False)
mc.setAttr(
(cInstance.obj.nameShort + '.' + cInstance.attr),
e=True,
channelBox=False)
guiFactory.report(
"'%s.%s' hidden!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.hidden = False
elif not self.hidden:
if self.keyable:
self.doKeyable(False)
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
channelBox=False)
guiFactory.report("'%s.%s' hidden!" %
(self.obj.nameShort, self.attr))
self.hidden = True
else:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if cInstance.hidden:
mc.setAttr(
(cInstance.obj.nameShort + '.' + cInstance.attr),
e=True,
channelBox=True)
guiFactory.report(
"'%s.%s' unhidden!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.hidden = False
elif self.hidden:
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
channelBox=True)
guiFactory.report("'%s.%s' unhidden!" %
(self.obj.nameShort, self.attr))
self.hidden = False
def doKeyable(self, arg=True):
"""
Set keyable state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if not cInstance.keyable:
mc.setAttr(cInstance.nameCombined,
e=True,
keyable=True)
guiFactory.report(
"'%s.%s' keyable!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.keyable = True
cInstance.hidden = False
elif not self.keyable:
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
keyable=True)
guiFactory.report("'%s.%s' keyable!" %
(self.obj.nameShort, self.attr))
self.keyable = True
self.hidden = False
else:
if self.children:
guiFactory.warning(
"'%s' has children, running set command on '%s'" %
(self.nameCombined, "','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort, c)
if cInstance.keyable:
mc.setAttr(
(cInstance.obj.nameShort + '.' + cInstance.attr),
e=True,
keyable=False)
guiFactory.report(
"'%s.%s' unkeyable!" %
(cInstance.obj.nameShort, cInstance.attr))
cInstance.keyable = False
if not mc.getAttr(cInstance.nameCombined,
channelBox=True):
cInstance.updateData()
cInstance.doHidden(False)
elif self.keyable:
mc.setAttr((self.obj.nameShort + '.' + self.attr),
e=True,
keyable=False)
guiFactory.report("'%s.%s' unkeyable!" %
(self.obj.nameShort, self.attr))
self.keyable = False
if not mc.getAttr(self.nameCombined, channelBox=True):
self.updateData()
self.doHidden(False)
def doAlias(self, arg):
"""
Set the alias of an attribute
Keyword arguments:
arg(string) -- name you want to use as an alias
"""
assert type(
arg) is str or unicode, "Must pass string argument into doAlias"
if arg:
try:
if arg != self.nameAlias:
if mc.aliasAttr(arg, self.nameCombined):
self.nameAlias = arg
else:
guiFactory.report("'%s.%s' already has that alias!" %
(self.obj.nameShort, self.attr, arg))
except:
guiFactory.warning("'%s.%s' failed to set alias of '%s'!" %
(self.obj.nameShort, self.attr, arg))
else:
if self.nameAlias:
self.attr = self.nameLong
mc.aliasAttr(self.nameCombined, remove=True)
self.nameAlias = False
self.updateData()
def doNiceName(self, arg):
"""
Set the nice name of an attribute
Keyword arguments:
arg(string) -- name you want to use as a nice name
"""
assert type(
arg) is str or unicode, "Must pass string argument into doNiceName"
if arg:
try:
mc.addAttr(self.nameCombined, edit=True, niceName=arg)
self.nameNice = arg
except:
guiFactory.warning("'%s.%s' failed to set nice name of '%s'!" %
(self.obj.nameShort, self.attr, arg))
def doRename(self, arg):
"""
Rename an attribute as something else
Keyword arguments:
arg(string) -- name you want to use as a nice name
"""
assert type(
arg) is str or unicode, "Must pass string argument into doRename"
if arg:
try:
if arg != self.nameLong:
attributes.doRenameAttr(self.obj.nameShort, self.nameLong,
arg)
self.attr = arg
self.updateData()
else:
guiFactory.report("'%s.%s' already has that nice name!" %
(self.obj.nameShort, self.attr, arg))
except:
guiFactory.warning("'%s.%s' failed to rename name of '%s'!" %
(self.obj.nameShort, self.attr, arg))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Connections and transfers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def returnCompatibleFromTarget(self, target, *a, **kw):
"""
Attempts to make a connection from instanced attribute to a target
Keyword arguments:
target(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(target), "'%s' doesn't exist" % target
return attributes.returnCompatibleAttrs(self.obj.nameShort,
self.nameLong, target, *a,
**kw)
def doConnectOut(self, target, *a, **kw):
"""
Attempts to make a connection from instanced attribute to a target
Keyword arguments:
target(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(target), "'%s' doesn't exist" % target
if '.' in target:
try:
attributes.doConnectAttr(self.nameCombined, target)
except:
guiFactory.warning("'%s' failed to connect to '%s'!" %
(self.nameCombined, target))
else:
#If the object has a transform
matchAttr = attributes.returnMatchNameAttrsDict(
self.obj.nameShort, target, [self.nameLong]) or []
if matchAttr:
#If it has a matching attribute
try:
attributes.doConnectAttr(
self.nameCombined,
('%s.%s' % (target, matchAttr.get(self.nameLong))))
except:
guiFactory.warning("'%s' failed to connect to '%s'!" %
(self.nameCombined, target))
else:
print "Target object doesn't have this particular attribute"
def doConnectIn(self, source, *a, **kw):
"""
Attempts to make a connection from a source to our instanced attribute
Keyword arguments:
source(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(source), "'%s' doesn't exist" % source
if '.' in source:
try:
attributes.doConnectAttr(source, self.nameCombined)
except:
guiFactory.warning("'%s' failed to connect to '%s'!" %
(source, self.nameCombined))
else:
#If the object has a transform
matchAttr = attributes.returnMatchNameAttrsDict(
self.obj.nameShort, source, [self.nameLong]) or []
if matchAttr:
#If it has a matching attribute
try:
attributes.doConnectAttr(
('%s.%s' % (source, matchAttr.get(self.nameLong))),
self.nameCombined)
except:
guiFactory.warning("'%s' failed to connect to '%s'!" %
(source, self.nameCombined))
else:
print "Source object doesn't have this particular attribute"
def doCopyTo(self, target, targetAttrName=None, debug=True, *a, **kw):
"""
Replacement for Maya's since maya's can't handle shapes....blrgh...
Copy attributes from one object to another as well as other options. If the attribute already
exists, it'll copy the values. If it doesn't, it'll make it. If it needs to convert, it can.
It will not make toast.
Keywords:
toObject(string) - obj to copy to
targetAttrName(string) -- name of the attr to copy to . Default is None which will create an
attribute oft the fromAttr name on the toObject if it doesn't exist
convertToMatch(bool) -- whether to convert if necessary.default True
values(bool) -- copy values. default True
inputConnections(bool) -- default False
outGoingConnections(bool) -- default False
keepSourceConnections(bool)-- keeps connections on source. default True
copyAttrSettings(bool) -- copy the attribute state of the fromAttr (keyable,lock,hidden). default True
connectSourceToTarget(bool) useful for moving attribute controls to another object. default False
RETURNS:
success(bool)
"""
assert mc.objExists(target), "'%s' doesn't exist" % target
assert mc.ls(target, long=True) != [self.obj.nameShort
], "Can't transfer to self!"
functionName = 'doCopyTo'
convertToMatch = kw.pop('convertToMatch', True)
values = kw.pop('values', True)
inputConnections = kw.pop('inputConnections', False)
outgoingConnections = kw.pop('outgoingConnections', False)
keepSourceConnections = kw.pop('keepSourceConnections', True)
copyAttrSettings = kw.pop('copyAttrSettings', True)
connectSourceToTarget = kw.pop('connectSourceToTarget', False)
connectTargetToSource = kw.pop('connectTargetToSource', False)
if debug:
guiFactory.doPrintReportStart(functionName)
guiFactory.report("AttrFactory instance: '%s'" % self.nameCombined)
guiFactory.report("convertToMatch: '%s'" % convertToMatch)
guiFactory.report("targetAttrName: '%s'" % targetAttrName)
guiFactory.report("inputConnections: '%s'" % inputConnections)
guiFactory.report("outgoingConnections: '%s'" %
outgoingConnections)
guiFactory.report("keepSourceConnections: '%s'" %
keepSourceConnections)
guiFactory.report("copyAttrSettings: '%s'" % copyAttrSettings)
guiFactory.report("connectSourceToTarget: '%s'" %
connectSourceToTarget)
guiFactory.report("keepSourceConnections: '%s'" %
keepSourceConnections)
guiFactory.report("connectTargetToSource: '%s'" %
connectTargetToSource)
guiFactory.doPrintReportBreak()
copyTest = [
values, inputConnections, outgoingConnections,
keepSourceConnections, connectSourceToTarget, copyAttrSettings
]
if sum(copyTest) < 1:
guiFactory.warning(
"You must have at least one option for copying selected. Otherwise, you're looking for the 'doDuplicate' function."
)
return False
if '.' in list(target):
targetBuffer = target.split('.')
if len(targetBuffer) == 2:
attributes.doCopyAttr(
self.obj.nameShort,
self.nameLong,
targetBuffer[0],
targetBuffer[1],
convertToMatch=convertToMatch,
values=values,
inputConnections=inputConnections,
outgoingConnections=outgoingConnections,
keepSourceConnections=keepSourceConnections,
copyAttrSettings=copyAttrSettings,
connectSourceToTarget=connectSourceToTarget)
else:
guiFactory.warning(
"Yeah, not sure what to do with this. Need an attribute call with only one '.'"
)
else:
attributes.doCopyAttr(self.obj.nameShort,
self.nameLong,
target,
targetAttrName,
convertToMatch=convertToMatch,
values=values,
inputConnections=inputConnections,
outgoingConnections=outgoingConnections,
keepSourceConnections=keepSourceConnections,
copyAttrSettings=copyAttrSettings,
connectSourceToTarget=connectSourceToTarget)
if debug:
guiFactory.doPrintReportEnd(functionName)
#except:
# guiFactory.warning("'%s' failed to copy to '%s'!"%(target,self.nameCombined))
def doTransferTo(self, target):
"""
Transfer an instanced attribute to a target with all settings and connections intact
Keyword arguments:
target(string) -- object to transfer it to
*a, **kw
"""
assert mc.objExists(target), "'%s' doesn't exist" % target
assert mc.ls(target, type='transform',
long=True), "'%s' Doesn't have a transform" % target
assert self.obj.transform is not False, "'%s' Doesn't have a transform. Transferring this attribute is probably a bad idea. Might we suggest doCopyTo along with a connect to source option" % self.obj.nameShort
assert mc.ls(target, long=True) != [self.obj.nameShort
], "Can't transfer to self!"
assert '.' not in list(
target
), "'%s' appears to be an attribute. Can't transfer to an attribute." % target
assert self.dynamic is True, "'%s' is not a dynamic attribute." % self.nameCombined
#mc.copyAttr(self.obj.nameShort,self.target.obj.nameShort,attribute = [self.target.attr],v = True,ic=True,oc=True,keepSourceConnections=True)
attributes.doCopyAttr(self.obj.nameShort,
self.nameLong,
target,
self.nameLong,
convertToMatch=True,
values=True,
inputConnections=True,
outgoingConnections=True,
keepSourceConnections=False,
copyAttrSettings=True,
connectSourceToTarget=False)
self.doDelete()
def __init__(self, characterName='', *a, **kw):
"""
Intializes an optionVar class handler
Keyword arguments:
varName(string) -- name for the optionVar
ObjectFactories:
self.PuppetNull - main null
self.NoTransformGroup
>>> self.GeoGroup - group where geo is stored to
self.PuppetInfoNull - master puppet info null under which the other nulls live
>>> self.GeoInfoNull
>>> self.ModuleInfoNull
>>> self.ModulesGroup
BufferFactories:
self.ModulesBuffer - buffer for modules. Instanced from self.ModuleInfoNull
"""
#>>>Keyword args
characterType = kw.pop('characterType', '')
initializeOnly = kw.pop('initializeOnly', False)
#Default to creation of a var as an int value of 0
### input check
self.masterNulls = modules.returnPuppetObjects()
self.nameBase = characterName
for l in initLists:
self.__dict__[l] = []
for d in initDicts:
self.__dict__[d] = {}
for o in initStores:
self.__dict__[o] = False
guiFactory.doPrintReportStart()
if mc.objExists(characterName):
#Make a name dict to check
if search.findRawTagInfo(characterName,
'cgmModuleType') == 'master':
self.nameBase = characterName
self.PuppetNull = ObjectFactory(characterName)
self.refState = self.PuppetNull.refState
guiFactory.report("'%s' exists. Checking..." % characterName)
else:
guiFactory.warning(
"'%s' isn't a puppet module. Can't initialize" %
characterName)
return
else:
if self.nameBase == '':
randomOptions = [
'ReallyNameMe', 'SolarSystem_isADumbName', 'David', 'Josh',
'Ryan', 'NameMe', 'Homer', 'Georgie', 'PleaseNameMe',
'NAMEThis', 'PleaseNameThisPuppet'
]
buffer = random.choice(randomOptions)
cnt = 0
while mc.objExists(buffer) and cnt < 10:
cnt += 1
buffer = random.choice(randomOptions)
self.nameBase = buffer
if self.refState or initializeOnly:
guiFactory.report("'%s' Initializing..." % characterName)
if not self.initialize():
guiFactory.warning(
"'%s' failed to initialize. Please go back to the non referenced file to repair!"
% moduleName)
return
else:
if not self.verify():
guiFactory.warning("'%s' failed to verify!" % characterName)
return
self.checkGeo()
self.verifyTemplateSizeObject(False)
self.getModules(initializeOnly=initializeOnly, *a, **kw)
guiFactory.report("'%s' checks out" % self.nameBase)
guiFactory.doPrintReportEnd()
class PuppetFactory():
"""
Character
"""
def __init__(self, characterName='', *a, **kw):
"""
Intializes an optionVar class handler
Keyword arguments:
varName(string) -- name for the optionVar
ObjectFactories:
self.PuppetNull - main null
self.NoTransformGroup
>>> self.GeoGroup - group where geo is stored to
self.PuppetInfoNull - master puppet info null under which the other nulls live
>>> self.GeoInfoNull
>>> self.ModuleInfoNull
>>> self.ModulesGroup
BufferFactories:
self.ModulesBuffer - buffer for modules. Instanced from self.ModuleInfoNull
"""
#>>>Keyword args
characterType = kw.pop('characterType', '')
initializeOnly = kw.pop('initializeOnly', False)
#Default to creation of a var as an int value of 0
### input check
self.masterNulls = modules.returnPuppetObjects()
self.nameBase = characterName
for l in initLists:
self.__dict__[l] = []
for d in initDicts:
self.__dict__[d] = {}
for o in initStores:
self.__dict__[o] = False
guiFactory.doPrintReportStart()
if mc.objExists(characterName):
#Make a name dict to check
if search.findRawTagInfo(characterName,
'cgmModuleType') == 'master':
self.nameBase = characterName
self.PuppetNull = ObjectFactory(characterName)
self.refState = self.PuppetNull.refState
guiFactory.report("'%s' exists. Checking..." % characterName)
else:
guiFactory.warning(
"'%s' isn't a puppet module. Can't initialize" %
characterName)
return
else:
if self.nameBase == '':
randomOptions = [
'ReallyNameMe', 'SolarSystem_isADumbName', 'David', 'Josh',
'Ryan', 'NameMe', 'Homer', 'Georgie', 'PleaseNameMe',
'NAMEThis', 'PleaseNameThisPuppet'
]
buffer = random.choice(randomOptions)
cnt = 0
while mc.objExists(buffer) and cnt < 10:
cnt += 1
buffer = random.choice(randomOptions)
self.nameBase = buffer
if self.refState or initializeOnly:
guiFactory.report("'%s' Initializing..." % characterName)
if not self.initialize():
guiFactory.warning(
"'%s' failed to initialize. Please go back to the non referenced file to repair!"
% moduleName)
return
else:
if not self.verify():
guiFactory.warning("'%s' failed to verify!" % characterName)
return
self.checkGeo()
self.verifyTemplateSizeObject(False)
self.getModules(initializeOnly=initializeOnly, *a, **kw)
guiFactory.report("'%s' checks out" % self.nameBase)
guiFactory.doPrintReportEnd()
def verify(self):
"""
Verifies the various components a masterNull for a character/asset. If a piece is missing it replaces it.
RETURNS:
success(bool)
"""
#Puppet null
try:
if not mc.objExists(self.nameBase):
buffer = mc.group(empty=True)
self.PuppetNull = ObjectFactory(buffer)
else:
self.PuppetNull = ObjectFactory(self.nameBase)
self.PuppetNull.store('cgmName', self.nameBase, True)
self.PuppetNull.store('cgmType', 'ignore')
self.PuppetNull.store('cgmModuleType', 'master')
if self.PuppetNull.nameShort != self.nameBase:
self.PuppetNull.doName(False)
attributes.doSetLockHideKeyableAttr(self.PuppetNull.nameShort,
channels=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz'
])
except:
guiFactory.warning("Puppet null failed!")
#Checks our modules container null
created = False
#Initialize message attr
self.msgModulesGroup = AttrFactory(self.PuppetNull, 'modulesGroup',
'message')
if not self.msgModulesGroup.get():
self.ModulesGroup = ObjectFactory(mc.group(empty=True))
self.msgModulesGroup.doStore(self.ModulesGroup.nameShort)
created = True
else:
self.ModulesGroup = ObjectFactory(self.msgModulesGroup.get())
self.ModulesGroup.store('cgmName', 'modules')
self.ModulesGroup.store('cgmType', 'group')
self.ModulesGroup.doParent(self.PuppetNull.nameShort)
if created:
self.ModulesGroup.doName(False)
self.msgModulesGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.ModulesGroup.nameShort)
#Checks our noTransform container null
created = False
self.msgNoTransformGroup = AttrFactory(self.PuppetNull,
'noTransformGroup', 'message')
if not self.msgNoTransformGroup.get():
self.NoTransformGroup = ObjectFactory(mc.group(empty=True))
self.msgNoTransformGroup.doStore(self.NoTransformGroup.nameShort)
created = True
else:
self.NoTransformGroup = ObjectFactory(
self.msgNoTransformGroup.get())
self.NoTransformGroup.store('cgmName', 'noTransform')
self.NoTransformGroup.store('cgmType', 'group')
self.NoTransformGroup.doParent(self.PuppetNull.nameShort)
if created:
self.NoTransformGroup.doName(False)
self.msgNoTransformGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.NoTransformGroup.nameShort)
#Checks our geo container null
created = False
self.msgGeoGroup = AttrFactory(self.PuppetNull, 'geoGroup', 'message')
if not self.msgGeoGroup.get():
self.GeoGroup = ObjectFactory(mc.group(empty=True))
self.msgGeoGroup.doStore(self.GeoGroup.nameShort)
created = True
else:
self.GeoGroup = ObjectFactory(self.msgGeoGroup.get())
self.GeoGroup.store('cgmName', 'geo')
self.GeoGroup.store('cgmType', 'group')
self.GeoGroup.doParent(self.msgNoTransformGroup.get())
if created:
self.GeoGroup.doName(False)
self.msgGeoGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.GeoGroup.nameShort)
#Checks master info null
created = False
self.msgPuppetInfo = AttrFactory(self.PuppetNull, 'info', 'message')
if not self.msgPuppetInfo.get():
self.PuppetInfoNull = ObjectFactory(mc.group(empty=True))
self.msgPuppetInfo.doStore(self.PuppetInfoNull.nameShort)
created = True
else:
self.PuppetInfoNull = ObjectFactory(self.msgPuppetInfo.get())
self.PuppetInfoNull.store('cgmName', 'master')
self.PuppetInfoNull.store('cgmType', 'info')
self.PuppetInfoNull.doParent(self.PuppetNull.nameShort)
if created:
self.PuppetInfoNull.doName(False)
self.msgPuppetInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.PuppetInfoNull.nameShort)
#Checks modules info null
created = False
self.msgModuleInfo = AttrFactory(self.msgPuppetInfo.get(), 'modules',
'message')
if not self.msgModuleInfo.get():
self.ModuleInfoNull = ObjectFactory(mc.group(empty=True))
self.msgModuleInfo.doStore(self.ModuleInfoNull.nameShort)
created = True
else:
self.ModuleInfoNull = ObjectFactory(self.msgModuleInfo.get())
self.ModuleInfoNull.store('cgmName', 'modules')
self.ModuleInfoNull.store('cgmType', 'info')
self.ModuleInfoNull.doParent(self.PuppetInfoNull.nameShort)
if created:
self.ModuleInfoNull.doName(False)
self.msgModuleInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.ModuleInfoNull.nameShort)
#Initialize our modules null as a buffer
self.ModulesBuffer = BufferFactory(self.ModuleInfoNull.nameShort)
#Checks geo info null
created = False
self.msgGeoInfo = AttrFactory(self.msgPuppetInfo.get(), 'geo',
'message')
if not self.msgGeoInfo.get():
self.GeoInfoNull = ObjectFactory(mc.group(empty=True))
self.msgGeoInfo.doStore(self.GeoInfoNull.nameShort)
created = True
else:
self.GeoInfoNull = ObjectFactory(self.msgGeoInfo.get())
self.GeoInfoNull.store('cgmName', 'geo')
self.GeoInfoNull.store('cgmType', 'info')
self.GeoInfoNull.doParent(self.msgPuppetInfo.get())
if created:
self.GeoInfoNull.doName(False)
self.msgGeoInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.GeoInfoNull.nameShort)
#Checks settings info null
created = False
self.msgSettingsInfo = AttrFactory(self.msgPuppetInfo.get(),
'settings', 'message')
if not self.msgSettingsInfo.get():
self.SettingsInfoNull = ObjectFactory(mc.group(empty=True))
self.msgSettingsInfo.doStore(self.SettingsInfoNull.nameShort)
created = True
else:
self.SettingsInfoNull = ObjectFactory(self.msgSettingsInfo.get())
self.SettingsInfoNull.store('cgmName', 'settings')
self.SettingsInfoNull.store('cgmType', 'info')
defaultFont = modules.returnSettingsData('defaultTextFont')
self.SettingsInfoNull.store('font', defaultFont)
self.SettingsInfoNull.doParent(self.msgPuppetInfo.get())
if created:
self.SettingsInfoNull.doName(False)
self.msgSettingsInfo.updateData()
self.optionPuppetMode = AttrFactory(self.SettingsInfoNull,
'optionPuppetTemplateMode',
'int',
initialValue=0)
self.optionAimAxis = AttrFactory(self.SettingsInfoNull,
'axisAim',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=2)
self.optionUpAxis = AttrFactory(self.SettingsInfoNull,
'axisUp',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=1)
self.optionOutAxis = AttrFactory(self.SettingsInfoNull,
'axisOut',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=0)
attributes.doSetLockHideKeyableAttr(self.SettingsInfoNull.nameShort)
return True
def initialize(self):
"""
Verifies the various components a masterNull for a character/asset. If a piece is missing it replaces it.
RETURNS:
success(bool)
"""
#Puppet null
if not attributes.doGetAttr(self.PuppetNull.nameShort, 'cgmName'):
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmType') != 'ignore':
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmModuleType') != 'master':
return False
self.msgModulesGroup = AttrFactory(self.PuppetNull, 'modulesGroup')
if not self.msgModulesGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModulesGroup.attr)
return False
else:
self.ModulesGroup = ObjectFactory(self.msgModulesGroup.get())
self.msgNoTransformGroup = AttrFactory(self.PuppetNull,
'noTransformGroup')
if not self.msgNoTransformGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgNoTransformGroup.attr)
return False
else:
self.NoTransformGroup = ObjectFactory(
self.msgNoTransformGroup.get())
self.msgGeoGroup = AttrFactory(self.PuppetNull, 'geoGroup')
if not self.msgGeoGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoGroup.attr)
return False
else:
self.GeoGroup = ObjectFactory(self.msgGeoGroup.get())
self.msgPuppetInfo = AttrFactory(self.PuppetNull, 'info')
if not self.msgPuppetInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgPuppetInfo.attr)
return False
else:
self.PuppetInfoNull = ObjectFactory(self.msgPuppetInfo.get())
self.msgModuleInfo = AttrFactory(self.PuppetInfoNull, 'modules')
if not self.msgModuleInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModuleInfo.attr)
return False
else:
#Initialize our modules null as a buffer
self.ModuleInfoNull = ObjectFactory(self.msgModuleInfo.get())
self.ModulesBuffer = BufferFactory(self.msgModuleInfo.get())
self.msgGeoInfo = AttrFactory(self.PuppetInfoNull, 'geo')
if not self.msgGeoInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoInfo.attr)
return False
else:
self.GeoInfoNull = ObjectFactory(self.msgGeoInfo.get())
self.msgSettingsInfo = AttrFactory(self.PuppetInfoNull, 'settings')
if not self.msgSettingsInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgSettingsInfo.attr)
return False
else:
self.SettingsInfoNull = ObjectFactory(
self.msgSettingsInfo.get(), )
self.optionPuppetMode = AttrFactory(
self.SettingsInfoNull, 'optionPuppetTemplateMode')
self.optionAimAxis = AttrFactory(self.SettingsInfoNull,
'axisAim')
self.optionUpAxis = AttrFactory(self.SettingsInfoNull,
'axisUp')
self.optionOutAxis = AttrFactory(self.SettingsInfoNull,
'axisOut')
return True
def delete(self):
"""
Delete the Puppet
"""
mc.delete(self.PuppetNull.nameLong)
self = False
def getState(self):
"""
Return a Puppet's state
Returns:
state/False -- (int)/(bool)
"""
checkList = []
if self.getModuleStates() is False:
return False
for k in self.moduleStates.keys():
checkList.append(self.moduleStates[k])
return min(checkList)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Modules
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def changeModuleCGMTag(self, moduleName, tag, newInfo, *a, **kw):
"""
Function to change a cgm tag on a module and push a rename through that moudule's instance
moduleName(string)
tag(string) which tag to use. For a list
###
from cgm.lib.classes import NameFactory
NameFactory.cgmNameTags
###
newInfo(*a,**kw) - info to pass into the attributes.storeInfo() function
"""
if moduleName in self.ModulesBuffer.bufferList:
#Clear our instanced module
index = self.ModulesBuffer.bufferList.index(moduleName)
modType = search.returnTagInfo(
self.Module[index].ModuleNull.nameShort, 'moduleType') or False
if index is not False:
if modType in moduleTypeToFunctionDict.keys():
if self.Module[index].changeCGMTag(tag, newInfo, *a, **kw):
self.Module[index] = moduleTypeToFunctionDict[modType](
self.Module[index].ModuleNull.nameShort)
self.ModulesBuffer.updateData()
else:
guiFactory.warning(
"'%s' is not a module type found in the moduleTypeToFunctionDict. Cannot initialize"
% modType)
return False
else:
guiFactory.warning("%s is not a valid index. Cannot continue" %
index)
return False
else:
guiFactory.warning(
"'%s' doesn't seem to be a connected module. Cannot change tag"
% moduleName)
return False
def getModules(self, *a, **kw):
"""
Intializes all connected modules of a puppet
"""
self.Module = {}
self.moduleIndexDict = {}
self.moduleParents = {}
self.ModulesBuffer.updateData()
if self.ModulesBuffer.bufferList:
for i, m in enumerate(self.ModulesBuffer.bufferList):
modType = search.returnTagInfo(m, 'moduleType') or False
if modType in moduleTypeToFunctionDict.keys():
self.Module[i] = moduleTypeToFunctionDict[modType](m, *a,
**kw)
self.Module[i].ModuleNull.doParent(
self.ModulesGroup.nameLong)
self.moduleIndexDict[m] = i
else:
guiFactory.warning(
"'%s' is not a module type found in the moduleTypeToFunctionDict. Cannot initialize"
% modType)
def getModuleStates(self, *a, **kw):
"""
Get's a dictionary of module states indexed to same indexes as the self.Module[i] format
"""
self.ModuleStates = {}
if self.ModulesBuffer.bufferList:
for i, m in enumerate(self.ModulesBuffer.bufferList):
self.moduleStates[i] = self.Module[i].getState()
else:
return False
return self.moduleStates
def createModule(self, moduleType, *a, **kw):
"""
Create and connect a new module
moduleType(string) - type of module to create
"""
if moduleType in moduleTypeToFunctionDict.keys():
tmpModule = moduleTypeToFunctionDict[moduleType](forceNew=True,
*a,
**kw)
self.ModulesBuffer.store(tmpModule.ModuleNull.nameShort)
tmpModule.ModuleNull.doParent(self.ModulesGroup.nameShort)
self.Module[self.ModulesBuffer.bufferList.index(
tmpModule.ModuleNull.nameShort)] = tmpModule
else:
guiFactory.warning(
"'%s' is not a module type found in the moduleTypeToFunctionDict. Cannot initialize"
% moduleType)
def addModule(self, module, *a, **kw):
"""
Adds a module to a puppet
module(string)
"""
if module in self.ModulesBuffer.bufferList:
return guiFactory.warning("'%s' already connnected to '%s'" %
(module, self.nameBase))
elif mc.objExists(module):
# If it exists, check type to initialize and add
modType = search.returnTagInfo(module, 'moduleType') or False
if modType in moduleTypeToFunctionDict.keys():
self.ModulesBuffer.store(module)
moduleNullBuffer = rigging.doParentReturnName(
module, self.msgModulesGroup.get())
self.Module[self.ModulesBuffer.bufferList.index(
module)] = moduleTypeToFunctionDict[modType](
moduleNullBuffer)
else:
guiFactory.warning(
"'%s' is not a module type found in the moduleTypeToFunctionDict. Cannot initialize"
)
else:
guiFactory.warning(
"'%s' is not a module type found in the moduleTypeToFunctionDict. Cannot initialize"
% module)
def removeModule(self, moduleName):
"""
Removes a module from a puppet
module(string)
"""
if moduleName in self.ModulesBuffer.bufferList:
#Clear our instanced module
index = self.ModulesBuffer.bufferList.index(moduleName)
if index is not False:
self.Module[index] = False
self.ModulesBuffer.remove(moduleName)
buffer = rigging.doParentToWorld(moduleName)
self.getModules()
else:
guiFactory.warning(
"'%s' doesn't seem to be a connected module. Cannot remove" %
moduleName)
def deleteModule(self, moduleName, *a, **kw):
"""
Removes a module from a puppet
module(string)
"""
if moduleName in self.ModulesBuffer.bufferList:
#Clear our instanced module
index = self.ModulesBuffer.bufferList.index(moduleName)
if index:
self.Module[index] = False
self.ModulesBuffer.remove(moduleName)
buffer = rigging.doParentToWorld(moduleName)
mc.delete(buffer)
self.getModules()
else:
guiFactory.warning(
"'%s' doesn't seem to be a connected module. Cannot delete" %
moduleName)
def getOrderedModules(self):
"""
Returns ordered modules of a character
Stores:
self.orderedModules(list)
Returns:
self.orderedModules(list)
"""
assert self.ModulesBuffer.bufferList, "'%s' has no modules" % self.nameBase
self.orderedModules = []
self.rootModules = []
moduleParents = {}
for i, m in enumerate(self.ModulesBuffer.bufferList):
if self.Module[i].moduleParent:
moduleParents[m] = self.Module[i].moduleParent
else:
self.orderedModules.append(m)
self.rootModules.append(m)
while len(moduleParents):
for module in self.orderedModules:
for k in moduleParents.keys():
if moduleParents.get(k) == module:
self.orderedModules.append(k)
moduleParents.pop(k)
return self.orderedModules
def getOrderedParentModules(self):
"""
Returns ordered list of parent modules of a character
Stores:
self.moduleChildren(dict)
self.orderedParentModules(list)
self.rootModules(list)
Returns:
self.orderedParentModules(list)
"""
moduleParents = {}
self.orderedParentModules = []
self.moduleChildren = {}
#First get our module children stored tothe instance as a dict
for i, m in enumerate(self.ModulesBuffer.bufferList):
if not self.Module[i].moduleParent:
self.orderedParentModules.append(m)
else:
moduleParents[m] = self.Module[i].moduleParent
childrenBuffer = []
for iCheck, mCheck in enumerate(self.ModulesBuffer.bufferList):
if self.Module[iCheck].moduleParent == m:
childrenBuffer.append(mCheck)
if childrenBuffer:
self.moduleChildren[m] = childrenBuffer
moduleChildrenD = copy.copy(self.moduleChildren)
# Pop the
if self.orderedParentModules:
for p in self.orderedParentModules:
try:
moduleChildrenD.pop(p)
except:
pass
cnt = 0
#Process the childdren looking for parents as children and so on and so forth, appending them as it finds them
while len(moduleChildrenD) > 0 and cnt < 100:
for module in self.orderedParentModules:
print module
for child in moduleChildrenD.keys():
cnt += 1
if child in moduleParents.keys(
) and moduleParents[child] == module:
self.orderedParentModules.append(child)
moduleChildrenD.pop(child)
guiFactory.report("Children dict is - '%s'" % self.moduleChildren)
guiFactory.report("Module Parents dict is - '%s'" % moduleParents)
guiFactory.report("Ordered Parents dict is - '%s'" %
self.orderedParentModules)
return self.orderedParentModules
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Size objects
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def verifyTemplateSizeObject(self, create=False):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Returns an existing template size object or makes one and returns it
ARGUMENTS:
masterNull(list)
RETURNS:
returnList(list) - size object controls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
templateSizeObject = attributes.returnMessageObject(
self.PuppetNull.nameShort, 'templateSizeObject')
if not mc.objExists(templateSizeObject) and create:
self.createSizeTemplateControl()
guiFactory.report("'%s' has template object '%s'" %
(self.PuppetNull.nameShort, templateSizeObject))
return True
elif templateSizeObject:
self.templateSizeObjects['root'] = templateSizeObject
self.templateSizeObjects['start'] = attributes.returnMessageObject(
templateSizeObject, 'controlStart')
self.templateSizeObjects['end'] = attributes.returnMessageObject(
templateSizeObject, 'controlEnd')
for key in self.templateSizeObjects.keys():
if not self.templateSizeObjects[key]:
#self.templateSizeObjects = {}
guiFactory.warning(
"'%s' didn't check out. Rebuildling..." % (key))
try:
mc.delete(templateSizeObject)
self.createSizeTemplateControl()
except:
guiFactory.warning("Rebuild failed")
return False
guiFactory.report("'%s' has template object '%s'" %
(self.PuppetNull.nameShort, templateSizeObject))
return True
guiFactory.warning("Size template failed to verify")
return False
def isRef(self):
"""
Basic ref check. Stores to self
"""
if mc.referenceQuery(self.PuppetNull.nameShort, isNodeReferenced=True):
self.refState = True
self.refPrefix = search.returnReferencePrefix(
self.PuppetNull.nameShort)
return
self.refState = False
self.refPrefix = None
def createSizeTemplateControl(self):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Generates a sizeTemplateObject. It's been deleted, it recreates it. Guess the size based off of there
being a mesh there. If there is no mesh, it sets sets an intial size of a
[155,170,29] unit character.
ARGUMENTS:
self.PuppetNull.nameShort(string)
RETURNS:
returnList(list) = [startCrv(string),EndCrv(list)]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Get info
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
startColors = modules.returnSettingsData('colorStart')
endColors = modules.returnSettingsData('colorEnd')
font = mc.getAttr((self.msgSettingsInfo.get() + '.font'))
""" checks for there being anything in our geo group """
if not self.geo:
return guiFactory.warning(
'Need some geo defined to make this tool worthwhile')
boundingBoxSize = modules.returnSettingsDataAsFloat(
'meshlessSizeTemplate')
else:
boundingBoxSize = distance.returnBoundingBoxSize(
self.msgGeoGroup.get())
boundingBox = mc.exactWorldBoundingBox(self.msgGeoGroup.get())
"""determine orienation """
maxSize = max(boundingBoxSize)
matchIndex = boundingBoxSize.index(maxSize)
"""Find the pivot of the bounding box """
pivotPosition = distance.returnCenterPivotPosition(
self.msgGeoGroup.get())
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Get our positions
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if self.optionPuppetMode.get() == 0:
#If bio...
if matchIndex == 1 or matchIndex == 0:
#Vertical
posBuffers = [[0, .5, 0], [0, .75, 0]]
width = (boundingBoxSize[0] / 2)
height = (boundingBoxSize[1])
depth = boundingBoxSize[2]
for cnt, pos in enumerate(posBuffers):
posBuffer = posBuffers[cnt]
posBuffer[0] = 0
posBuffer[1] = (posBuffer[1] * height)
posBuffer[2] = 0
elif matchIndex == 2:
#Horizontal
posBuffers = [[0, 0, -.33], [0, 0, .66]]
width = boundingBoxSize[1]
height = boundingBoxSize[2] / 2
depth = (boundingBoxSize[0])
for cnt, pos in enumerate(posBuffers):
posBuffer = posBuffers[cnt]
posBuffer[0] = 0
posBuffer[1] = boundingBoxSize[1] * .75
posBuffer[2] = (posBuffer[2] * height)
else:
#Otherwise
if matchIndex == 1 or matchIndex == 0:
#Vertical
width = (boundingBoxSize[0] / 2)
height = (boundingBoxSize[1])
depth = boundingBoxSize[2]
posBuffers = [[0, boundingBox[1], 0], [0, boundingBox[4], 0]]
elif matchIndex == 2:
#Horizontal
width = boundingBoxSize[0]
height = boundingBoxSize[2] / 2
depth = (boundingBoxSize[1])
startHeight = max([boundingBox[4], boundingBox[1]]) - depth / 2
print startHeight
posBuffers = [[0, startHeight, boundingBox[2]],
[0, startHeight, boundingBox[5]]]
# Simple reverse of start pos buffers if the object is pointing negative
if self.optionAimAxis < 2:
posBuffers.reverse()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Making the controls
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" make our control object """
startCurves = []
startCurve = curves.createControlCurve('circle', depth * .8)
mc.xform(startCurve, t=posBuffers[0], ws=True)
attributes.doSetAttr(startCurve, 'rotateOrder', 5)
curves.setCurveColorByName(startCurve, startColors[1])
startCurves.append(startCurve)
startText = curves.createTextCurve('start',
size=depth * .75,
font=font)
mc.xform(startText, t=posBuffers[0], ws=True)
curves.setCurveColorByName(startText, startColors[0])
startCurves.append(startText)
endCurves = []
endCurve = curves.createControlCurve('circle', depth * .8)
mc.xform(endCurve, t=posBuffers[1], ws=True)
curves.setCurveColorByName(endCurve, endColors[1])
attributes.doSetAttr(endCurve, 'rotateOrder', 5)
endCurves.append(endCurve)
endText = curves.createTextCurve('end', size=depth * .6, font=font)
mc.xform(endText, t=posBuffers[1], ws=True)
curves.setCurveColorByName(endText, endColors[0])
endCurves.append(endText)
""" aiming """
position.aimSnap(startCurve, endCurve, [0, 0, 1], [0, 1, 0])
position.aimSnap(startText, endCurve, [0, 0, 1], [0, 1, 0])
position.aimSnap(endCurve, startCurve, [0, 0, -1], [0, 1, 0])
position.aimSnap(endText, startCurve, [0, 0, -1], [0, 1, 0])
sizeCurveControlStart = curves.combineCurves(startCurves)
sizeCurveControlEnd = curves.combineCurves(endCurves)
""" store our info to name our objects"""
attributes.storeInfo(sizeCurveControlStart, 'cgmName',
(self.PuppetNull.nameShort + '.cgmName'))
attributes.storeInfo(sizeCurveControlStart, 'cgmDirection', 'start')
attributes.storeInfo(sizeCurveControlStart, 'cgmType',
'templateSizeObject')
sizeCurveControlStart = NameFactory.doNameObject(sizeCurveControlStart)
mc.makeIdentity(sizeCurveControlStart,
apply=True,
t=True,
s=True,
r=True)
attributes.storeInfo(sizeCurveControlEnd, 'cgmName',
(self.PuppetNull.nameShort + '.cgmName'))
attributes.storeInfo(sizeCurveControlEnd, 'cgmDirection', 'end')
attributes.storeInfo(sizeCurveControlEnd, 'cgmType',
'templateSizeObject')
sizeCurveControlEnd = NameFactory.doNameObject(sizeCurveControlEnd)
endGroup = rigging.groupMeObject(sizeCurveControlEnd)
mc.makeIdentity(sizeCurveControlEnd,
apply=True,
t=True,
s=True,
r=True)
mc.parentConstraint(sizeCurveControlStart,
endGroup,
maintainOffset=True)
""" make control group """
controlGroup = rigging.groupMeObject(sizeCurveControlStart)
attributes.storeInfo(controlGroup, 'cgmName',
(self.PuppetNull.nameShort + '.cgmName'))
attributes.storeInfo(controlGroup, 'cgmType',
'templateSizeObjectGroup')
controlGroup = NameFactory.doNameObject(controlGroup)
endGroup = rigging.doParentReturnName(endGroup, controlGroup)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Getting data ready
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
attributes.storeInfo(controlGroup, 'controlStart',
sizeCurveControlStart)
attributes.storeInfo(controlGroup, 'controlEnd', sizeCurveControlEnd)
attributes.storeInfo(self.PuppetNull.nameShort, 'templateSizeObject',
controlGroup)
self.templateSizeObjects['root'] = controlGroup
self.templateSizeObjects['start'] = sizeCurveControlStart
self.templateSizeObjects['end'] = sizeCurveControlEnd
returnList = []
returnList.append(sizeCurveControlStart)
returnList.append(sizeCurveControlEnd)
return returnList
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Geo Stuff
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def addGeo(self):
"""
Add geo to a puppet
"""
assert self.msgGeoGroup.get() is not False, "No geo group found!"
selection = mc.ls(sl=True, flatten=True, long=True) or []
if not selection:
guiFactory.warning("No selection found to add to '%s'" %
self.nameBase)
returnList = []
for o in selection:
if search.returnObjectType(o) in geoTypes:
if self.msgGeoGroup.get() not in search.returnAllParents(
o, True):
o = rigging.doParentReturnName(o, self.msgGeoGroup.get())
self.geo.append(o)
else:
guiFactory.warning("'%s' already a part of '%s'" %
(o, self.nameBase))
else:
guiFactory.warning(
"'%s' doesn't seem to be geo. Not added to '%s'" %
(o, self.nameBase))
def checkGeo(self):
"""
Check a puppet's geo that it is actually geo
"""
assert self.msgGeoGroup.get() is not False, "No geo group found!"
children = search.returnAllChildrenObjects(self.msgGeoGroup.get())
if not children:
return False
for o in children:
if search.returnObjectType(o) in geoTypes:
buff = mc.ls(o, long=True)
self.geo.append(buff[0])
else:
rigging.doParentToWorld(o)
guiFactory.warning("'%s' isn't geo, removing from group." % o)
return True
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Data setting stuff
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def doSetMode(self, i):
assert i < (
len(CharacterTypes)), "%i isn't a viable base pupppet type" % i
self.optionPuppetMode.set(i)
def doSetAimAxis(self, i):
"""
Set the aim axis. if up or out have that axis. They will be changed. Aim is the priority.
Then Up, and Out is last.
"""
assert i < 6, "%i isn't a viable aim axis integer" % i
self.optionAimAxis.set(i)
if self.optionUpAxis.get() == self.optionAimAxis.get():
self.doSetUpAxis(i)
if self.optionOutAxis.get() == self.optionAimAxis.get():
self.doSetOutAxis(i)
return True
def doSetUpAxis(self, i):
"""
Set the aim axis. if up or out have that axis. They will be changed. Aim is the priority.
Then Up, and Out is last.
"""
assert i < 6, "%i isn't a viable up axis integer" % i
axisBuffer = range(6)
axisBuffer.remove(self.optionAimAxis.get())
if i != self.optionAimAxis.get():
self.optionUpAxis.set(i)
else:
self.optionUpAxis.set(axisBuffer[0])
guiFactory.warning(
"Aim axis has '%s'. Changed up axis to '%s'. Change aim setting if you want this seeting"
% (axisDirectionsByString[self.optionAimAxis.get()],
axisDirectionsByString[self.optionUpAxis.get()]))
axisBuffer.remove(axisBuffer[0])
if self.optionOutAxis.get() in [
self.optionAimAxis.get(),
self.optionUpAxis.get()
]:
for i in axisBuffer:
if i not in [
self.optionAimAxis.get(),
self.optionUpAxis.get()
]:
self.doSetOutAxis(i)
guiFactory.warning(
"Setting conflict. Changed out axis to '%s'" %
axisDirectionsByString[i])
break
return True
def doSetOutAxis(self, i):
assert i < 6, "%i isn't a viable aim axis integer" % i
if i not in [self.optionAimAxis.get(), self.optionUpAxis.get()]:
self.optionOutAxis.set(i)
else:
axisBuffer = range(6)
axisBuffer.remove(self.optionAimAxis.get())
axisBuffer.remove(self.optionUpAxis.get())
self.optionOutAxis.set(axisBuffer[0])
guiFactory.warning("Setting conflict. Changed out axis to '%s'" %
axisDirectionsByString[axisBuffer[0]])
def doRenamePuppet(self, newName):
"""
Rename Puppet null
"""
if newName == self.PuppetNull.cgm['cgmName']:
return guiFactory.warning("Already named '%s'" % newName)
self.PuppetNull.store('cgmName ', newName)
self.nameBase = newName
self.PuppetNull.doName()
self.verify()
self.getModules()
guiFactory.warning("Puppet renamed as '%s'" % newName)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Sizing
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def doSize(self):
"""
Function to size a puppet
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Get Info
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
### TemplateSizeObject Check ###
if not self.ModulesBuffer.bufferList:
raise StandardError, "'%s' has no modules" % self.PuppetNull.nameLong
if not self.templateSizeObjects:
raise StandardError, "'%s' has no size template" % self.PuppetNull.nameLong
basicOrientation = logic.returnHorizontalOrVertical([
self.templateSizeObjects['start'], self.templateSizeObjects['end']
])
print basicOrientation
# Get module info
if not self.getOrderedModules() and self.getOrderedParentModules():
guiFactory.warning(
"Failed to get ordered module info, here's what we got...")
guiFactory.report("Ordered modules - %s" % self.orderedModules)
guiFactory.report("Ordered parent modules - %s" %
self.orderedParentModules)
guiFactory.report("Module children- %s" % self.moduleChildren)
##Delete this later
guiFactory.report("Ordered modules - %s" % self.orderedModules)
guiFactory.report("Ordered parent modules - %s" %
self.orderedParentModules)
guiFactory.report("Module children- %s" % self.moduleChildren)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Get our initial data
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.sizeCorePositionList = {}
self.sizeLocInfo = {}
checkList = {}
orderedListCopy = copy.copy(self.orderedModules)
for m in self.orderedModules:
checkList[m] = False
# first do the root modules """
for m in self.rootModules:
#Size each module and store it
if not self.Module[self.moduleIndexDict[m]].doInitialSize(self):
guiFactory.warning("Failed to get a size return on '%s'" % m)
return False
checkList.pop(m)
orderedListCopy.remove(m)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# NEED TO DO CHILDREN MODULES NEXT
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Delete the temp locs
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
for i,m in enumerate(self.ModulesBuffer.bufferList):
buffer = self.sizeLocInfo[m]
parentBuffer = search.returnAllParents( buffer )
if mc.objExists(parentBuffer[-1]):
mc.delete(parentBuffer[-1])"""
return
def initialize(self):
"""
Verifies the various components a masterNull for a character/asset. If a piece is missing it replaces it.
RETURNS:
success(bool)
"""
#Puppet null
if not attributes.doGetAttr(self.PuppetNull.nameShort, 'cgmName'):
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmType') != 'ignore':
return False
if attributes.doGetAttr(self.PuppetNull.nameShort,
'cgmModuleType') != 'master':
return False
self.msgModulesGroup = AttrFactory(self.PuppetNull, 'modulesGroup')
if not self.msgModulesGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModulesGroup.attr)
return False
else:
self.ModulesGroup = ObjectFactory(self.msgModulesGroup.get())
self.msgNoTransformGroup = AttrFactory(self.PuppetNull,
'noTransformGroup')
if not self.msgNoTransformGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgNoTransformGroup.attr)
return False
else:
self.NoTransformGroup = ObjectFactory(
self.msgNoTransformGroup.get())
self.msgGeoGroup = AttrFactory(self.PuppetNull, 'geoGroup')
if not self.msgGeoGroup.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoGroup.attr)
return False
else:
self.GeoGroup = ObjectFactory(self.msgGeoGroup.get())
self.msgPuppetInfo = AttrFactory(self.PuppetNull, 'info')
if not self.msgPuppetInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgPuppetInfo.attr)
return False
else:
self.PuppetInfoNull = ObjectFactory(self.msgPuppetInfo.get())
self.msgModuleInfo = AttrFactory(self.PuppetInfoNull, 'modules')
if not self.msgModuleInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgModuleInfo.attr)
return False
else:
#Initialize our modules null as a buffer
self.ModuleInfoNull = ObjectFactory(self.msgModuleInfo.get())
self.ModulesBuffer = BufferFactory(self.msgModuleInfo.get())
self.msgGeoInfo = AttrFactory(self.PuppetInfoNull, 'geo')
if not self.msgGeoInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgGeoInfo.attr)
return False
else:
self.GeoInfoNull = ObjectFactory(self.msgGeoInfo.get())
self.msgSettingsInfo = AttrFactory(self.PuppetInfoNull, 'settings')
if not self.msgSettingsInfo.get():
guiFactory.warning(
"'%s' looks to be missing. Go back to unreferenced file" %
self.msgSettingsInfo.attr)
return False
else:
self.SettingsInfoNull = ObjectFactory(
self.msgSettingsInfo.get(), )
self.optionPuppetMode = AttrFactory(
self.SettingsInfoNull, 'optionPuppetTemplateMode')
self.optionAimAxis = AttrFactory(self.SettingsInfoNull,
'axisAim')
self.optionUpAxis = AttrFactory(self.SettingsInfoNull,
'axisUp')
self.optionOutAxis = AttrFactory(self.SettingsInfoNull,
'axisOut')
return True
def verify(self):
"""
Verifies the various components a masterNull for a character/asset. If a piece is missing it replaces it.
RETURNS:
success(bool)
"""
#Puppet null
try:
if not mc.objExists(self.nameBase):
buffer = mc.group(empty=True)
self.PuppetNull = ObjectFactory(buffer)
else:
self.PuppetNull = ObjectFactory(self.nameBase)
self.PuppetNull.store('cgmName', self.nameBase, True)
self.PuppetNull.store('cgmType', 'ignore')
self.PuppetNull.store('cgmModuleType', 'master')
if self.PuppetNull.nameShort != self.nameBase:
self.PuppetNull.doName(False)
attributes.doSetLockHideKeyableAttr(self.PuppetNull.nameShort,
channels=[
'tx', 'ty', 'tz', 'rx',
'ry', 'rz', 'sx', 'sy',
'sz'
])
except:
guiFactory.warning("Puppet null failed!")
#Checks our modules container null
created = False
#Initialize message attr
self.msgModulesGroup = AttrFactory(self.PuppetNull, 'modulesGroup',
'message')
if not self.msgModulesGroup.get():
self.ModulesGroup = ObjectFactory(mc.group(empty=True))
self.msgModulesGroup.doStore(self.ModulesGroup.nameShort)
created = True
else:
self.ModulesGroup = ObjectFactory(self.msgModulesGroup.get())
self.ModulesGroup.store('cgmName', 'modules')
self.ModulesGroup.store('cgmType', 'group')
self.ModulesGroup.doParent(self.PuppetNull.nameShort)
if created:
self.ModulesGroup.doName(False)
self.msgModulesGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.ModulesGroup.nameShort)
#Checks our noTransform container null
created = False
self.msgNoTransformGroup = AttrFactory(self.PuppetNull,
'noTransformGroup', 'message')
if not self.msgNoTransformGroup.get():
self.NoTransformGroup = ObjectFactory(mc.group(empty=True))
self.msgNoTransformGroup.doStore(self.NoTransformGroup.nameShort)
created = True
else:
self.NoTransformGroup = ObjectFactory(
self.msgNoTransformGroup.get())
self.NoTransformGroup.store('cgmName', 'noTransform')
self.NoTransformGroup.store('cgmType', 'group')
self.NoTransformGroup.doParent(self.PuppetNull.nameShort)
if created:
self.NoTransformGroup.doName(False)
self.msgNoTransformGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.NoTransformGroup.nameShort)
#Checks our geo container null
created = False
self.msgGeoGroup = AttrFactory(self.PuppetNull, 'geoGroup', 'message')
if not self.msgGeoGroup.get():
self.GeoGroup = ObjectFactory(mc.group(empty=True))
self.msgGeoGroup.doStore(self.GeoGroup.nameShort)
created = True
else:
self.GeoGroup = ObjectFactory(self.msgGeoGroup.get())
self.GeoGroup.store('cgmName', 'geo')
self.GeoGroup.store('cgmType', 'group')
self.GeoGroup.doParent(self.msgNoTransformGroup.get())
if created:
self.GeoGroup.doName(False)
self.msgGeoGroup.updateData()
attributes.doSetLockHideKeyableAttr(self.GeoGroup.nameShort)
#Checks master info null
created = False
self.msgPuppetInfo = AttrFactory(self.PuppetNull, 'info', 'message')
if not self.msgPuppetInfo.get():
self.PuppetInfoNull = ObjectFactory(mc.group(empty=True))
self.msgPuppetInfo.doStore(self.PuppetInfoNull.nameShort)
created = True
else:
self.PuppetInfoNull = ObjectFactory(self.msgPuppetInfo.get())
self.PuppetInfoNull.store('cgmName', 'master')
self.PuppetInfoNull.store('cgmType', 'info')
self.PuppetInfoNull.doParent(self.PuppetNull.nameShort)
if created:
self.PuppetInfoNull.doName(False)
self.msgPuppetInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.PuppetInfoNull.nameShort)
#Checks modules info null
created = False
self.msgModuleInfo = AttrFactory(self.msgPuppetInfo.get(), 'modules',
'message')
if not self.msgModuleInfo.get():
self.ModuleInfoNull = ObjectFactory(mc.group(empty=True))
self.msgModuleInfo.doStore(self.ModuleInfoNull.nameShort)
created = True
else:
self.ModuleInfoNull = ObjectFactory(self.msgModuleInfo.get())
self.ModuleInfoNull.store('cgmName', 'modules')
self.ModuleInfoNull.store('cgmType', 'info')
self.ModuleInfoNull.doParent(self.PuppetInfoNull.nameShort)
if created:
self.ModuleInfoNull.doName(False)
self.msgModuleInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.ModuleInfoNull.nameShort)
#Initialize our modules null as a buffer
self.ModulesBuffer = BufferFactory(self.ModuleInfoNull.nameShort)
#Checks geo info null
created = False
self.msgGeoInfo = AttrFactory(self.msgPuppetInfo.get(), 'geo',
'message')
if not self.msgGeoInfo.get():
self.GeoInfoNull = ObjectFactory(mc.group(empty=True))
self.msgGeoInfo.doStore(self.GeoInfoNull.nameShort)
created = True
else:
self.GeoInfoNull = ObjectFactory(self.msgGeoInfo.get())
self.GeoInfoNull.store('cgmName', 'geo')
self.GeoInfoNull.store('cgmType', 'info')
self.GeoInfoNull.doParent(self.msgPuppetInfo.get())
if created:
self.GeoInfoNull.doName(False)
self.msgGeoInfo.updateData()
attributes.doSetLockHideKeyableAttr(self.GeoInfoNull.nameShort)
#Checks settings info null
created = False
self.msgSettingsInfo = AttrFactory(self.msgPuppetInfo.get(),
'settings', 'message')
if not self.msgSettingsInfo.get():
self.SettingsInfoNull = ObjectFactory(mc.group(empty=True))
self.msgSettingsInfo.doStore(self.SettingsInfoNull.nameShort)
created = True
else:
self.SettingsInfoNull = ObjectFactory(self.msgSettingsInfo.get())
self.SettingsInfoNull.store('cgmName', 'settings')
self.SettingsInfoNull.store('cgmType', 'info')
defaultFont = modules.returnSettingsData('defaultTextFont')
self.SettingsInfoNull.store('font', defaultFont)
self.SettingsInfoNull.doParent(self.msgPuppetInfo.get())
if created:
self.SettingsInfoNull.doName(False)
self.msgSettingsInfo.updateData()
self.optionPuppetMode = AttrFactory(self.SettingsInfoNull,
'optionPuppetTemplateMode',
'int',
initialValue=0)
self.optionAimAxis = AttrFactory(self.SettingsInfoNull,
'axisAim',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=2)
self.optionUpAxis = AttrFactory(self.SettingsInfoNull,
'axisUp',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=1)
self.optionOutAxis = AttrFactory(self.SettingsInfoNull,
'axisOut',
'enum',
enum='x+:y+:z+:x-:y-:z-',
initialValue=0)
attributes.doSetLockHideKeyableAttr(self.SettingsInfoNull.nameShort)
return True
def __init__(self,objName,attrName,attrType = False,value = None,enum = False,initialValue = None,lock = None,keyable = None, hidden = None, *a, **kw):
"""
Asserts object's existance and that it has a transform. Then initializes. If
an existing attribute name on an object is called and the attribute type is different,it converts it. All functions
ignore locks on attributes and will act when called regardless of target settings
Keyword arguments:
obj(string) -- must exist in scene or an ObjectFactory instance
attrName(string) -- name for an attribute to initialize
attrType(string) -- must be valid attribute type. If AttrFactory is imported, you can type 'print attrTypesDict'
enum(string) -- default enum list to set on call or recall
value() -- set value on call
initialValue() -- only set on creation
*a, **kw
"""
### input check
try:
#If we have an Object Factory instance, link it
objName.nameShort
self.obj = objName
except:
#If it fails, check that the object name exists and if so, initialize a new Object Factory instance
assert mc.objExists(objName) is True, "'%s' doesn't exist" %objName
self.obj = ObjectFactory(objName)
self.form = attributes.validateRequestedAttrType(attrType)
self.attr = attrName
self.children = False
initialCreate = False
# If it exists we need to check the type.
if mc.objExists('%s.%s'%(self.obj.nameShort,attrName)):
currentType = mc.getAttr('%s.%s'%(self.obj.nameShort,attrName),type=True)
if not attributes.validateAttrTypeMatch(attrType,currentType) and self.form is not False:
if self.obj.refState:
return guiFactory.warning("'%s' is referenced. cannot convert '%s' to '%s'!"%(self.obj.nameShort,attrName,attrType))
self.doConvert(attrType)
else:
self.attr = attrName
self.form = currentType
else:
try:
if self.form == False:
self.form = 'string'
attributes.addStringAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'double':
attributes.addFloatAttributeToObject(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'string':
attributes.addStringAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'long':
attributes.addIntegerAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'double3':
attributes.addVectorAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'enum':
attributes.addEnumAttrToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'bool':
attributes.addBoolAttrToObject(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'message':
attributes.addMessageAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
else:
guiFactory.warning("'%s' is an unknown form to this class"%(self.form))
return False
initialCreate = True
except:
guiFactory.warning("'%s.%s' failed to add"%(self.obj.nameShort,attrName))
self.updateData(*a, **kw)
if enum:
try:
self.setEnum(enum)
except:
guiFactory.warning("Failed to set enum value of '%s'"%enum)
if initialValue is not None and initialCreate:
self.set(initialValue)
elif value is not None:
self.set(value)
if type(keyable) is bool:
self.doKeyable(keyable)
if type(hidden) is bool:
self.doHidden(hidden)
if type(lock) is bool:
self.doLocked(lock)
class AttrFactory():
"""
Initialized a maya attribute as a class obj
"""
def __init__(self,objName,attrName,attrType = False,value = None,enum = False,initialValue = None,lock = None,keyable = None, hidden = None, *a, **kw):
"""
Asserts object's existance and that it has a transform. Then initializes. If
an existing attribute name on an object is called and the attribute type is different,it converts it. All functions
ignore locks on attributes and will act when called regardless of target settings
Keyword arguments:
obj(string) -- must exist in scene or an ObjectFactory instance
attrName(string) -- name for an attribute to initialize
attrType(string) -- must be valid attribute type. If AttrFactory is imported, you can type 'print attrTypesDict'
enum(string) -- default enum list to set on call or recall
value() -- set value on call
initialValue() -- only set on creation
*a, **kw
"""
### input check
try:
#If we have an Object Factory instance, link it
objName.nameShort
self.obj = objName
except:
#If it fails, check that the object name exists and if so, initialize a new Object Factory instance
assert mc.objExists(objName) is True, "'%s' doesn't exist" %objName
self.obj = ObjectFactory(objName)
self.form = attributes.validateRequestedAttrType(attrType)
self.attr = attrName
self.children = False
initialCreate = False
# If it exists we need to check the type.
if mc.objExists('%s.%s'%(self.obj.nameShort,attrName)):
currentType = mc.getAttr('%s.%s'%(self.obj.nameShort,attrName),type=True)
if not attributes.validateAttrTypeMatch(attrType,currentType) and self.form is not False:
if self.obj.refState:
return guiFactory.warning("'%s' is referenced. cannot convert '%s' to '%s'!"%(self.obj.nameShort,attrName,attrType))
self.doConvert(attrType)
else:
self.attr = attrName
self.form = currentType
else:
try:
if self.form == False:
self.form = 'string'
attributes.addStringAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'double':
attributes.addFloatAttributeToObject(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'string':
attributes.addStringAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'long':
attributes.addIntegerAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'double3':
attributes.addVectorAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'enum':
attributes.addEnumAttrToObj(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'bool':
attributes.addBoolAttrToObject(self.obj.nameShort,attrName,*a, **kw)
elif self.form == 'message':
attributes.addMessageAttributeToObj(self.obj.nameShort,attrName,*a, **kw)
else:
guiFactory.warning("'%s' is an unknown form to this class"%(self.form))
return False
initialCreate = True
except:
guiFactory.warning("'%s.%s' failed to add"%(self.obj.nameShort,attrName))
self.updateData(*a, **kw)
if enum:
try:
self.setEnum(enum)
except:
guiFactory.warning("Failed to set enum value of '%s'"%enum)
if initialValue is not None and initialCreate:
self.set(initialValue)
elif value is not None:
self.set(value)
if type(keyable) is bool:
self.doKeyable(keyable)
if type(hidden) is bool:
self.doHidden(hidden)
if type(lock) is bool:
self.doLocked(lock)
#guiFactory.report("'%s.%s' >> '%s' >> is '%s'"%(self.obj.nameShort,self.attr,self.value,self.form))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Base Functions
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def updateData(self,*a, **kw):
"""
Get's attr updated data
"""
assert mc.objExists('%s.%s'%(self.obj.nameShort,self.attr)) is True, "'%s.%s' doesn't exist" %(self.obj.nameShort,self.attr)
# Default attrs
self.nameCombined = '%s.%s'%(self.obj.nameShort,self.attr)
self.minValue = False
self.maxValue = False
self.defaultValue = False
self.nameNice = mc.attributeQuery(self.attr, node = self.obj.nameShort, niceName = True)
self.nameLong = mc.attributeQuery(self.attr, node = self.obj.nameShort, longName = True)
self.nameAlias = False
if mc.aliasAttr(self.nameCombined,q=True):
self.nameAlias = mc.aliasAttr(self.nameCombined,q=True)
self.get(*a, **kw)
#>>> Parent Stuff
pBuffer = mc.attributeQuery(self.attr, node = self.obj.nameShort, listParent=True)
if pBuffer is None:
self.parent = False
else:
self.parent = pBuffer[0]
self.children = mc.attributeQuery(self.attr, node = self.obj.nameShort, listChildren=True)
if self.children is None:
self.children = False
self.siblings = mc.attributeQuery(self.attr, node = self.obj.nameShort, listSiblings=True)
if self.siblings is None:
self.siblings = False
self.enum = False
self.userAttrs = mc.listAttr(self.obj.nameShort, userDefined = True) or []
standardFlagsBuffer = attributes.returnStandardAttrFlags(self.obj.nameShort,self.nameLong)
standardDataBuffer = attributes.returnAttributeDataDict(self.obj.nameShort,self.nameLong)
#Check connections
self.driver = attributes.returnDriverAttribute(self.nameCombined,False)
self.driven = attributes.returnDrivenAttribute(self.nameCombined,False)
self.numeric = standardFlagsBuffer.get('numeric')
self.dynamic = standardFlagsBuffer.get('dynamic')
self.locked = standardFlagsBuffer.get('locked')
self.keyable = standardFlagsBuffer.get('keyable')
self.hidden = standardFlagsBuffer.get('hidden')
if self.dynamic:
self.readable = standardFlagsBuffer.get('readable')
self.writable = standardFlagsBuffer.get('writable')
self.storable = standardFlagsBuffer.get('storable')
self.usedAsColor = standardFlagsBuffer.get('usedAsColor')
#>>> Numeric
if self.numeric:
bufferDict = attributes.returnNumericAttrSettingsDict(self.obj.nameShort,self.nameLong)
if bufferDict:
self.maxValue = bufferDict.get('max')
self.minValue = bufferDict.get('min')
self.defaultValue = bufferDict.get('default')
self.softMaxValue = bufferDict.get('softMax')
self.softMinValue = bufferDict.get('softMin')
self.rangeValue = bufferDict.get('range')
self.softRangeValue = bufferDict.get('softRange')
else:
self.maxValue = False
self.minValue = False
self.defaultValue = False
self.softMaxValue = False
self.softMinValue = False
self.rangeValue = False
self.softRangeValue = False
if self.form == 'enum':
self.enum = standardFlagsBuffer.get('enum')
def doConvert(self,attrType):
"""
Converts an attribute type from one to another while preserving as much data as possible.
Keyword arguments:
attrType(string)
"""
self.updateData()
if self.obj.refState:
return guiFactory.warning("'%s' is referenced. cannot convert '%s' to '%s'!"%(self.obj.nameShort,self.attr,attrType))
if self.children:
return guiFactory.warning("'%s' has children, can't convert"%self.nameCombined)
keyable = copy.copy(self.keyable)
hidden = copy.copy(self.hidden)
locked = copy.copy(self.locked)
storedNumeric = False
if self.numeric and not self.children:
storedNumeric = True
minimum = copy.copy(self.minValue)
maximum = copy.copy(self.maxValue)
default = copy.copy(self.defaultValue)
softMin = copy.copy(self.softMinValue)
softMax = copy.copy(self.softMaxValue)
attributes.doConvertAttrType(self.nameCombined,attrType)
self.updateData()
#>>> Reset variables
self.doHidden(hidden)
self.doKeyable(keyable)
self.doLocked(locked)
if self.numeric and not self.children and storedNumeric:
if softMin is not False or int(softMin) !=0 :
self.doSoftMin(softMin)
if softMax is not False or int(softMax) !=0 :
self.doSoftMax(softMax)
if minimum is not False:
self.doMin(minimum)
if maximum is not False:
self.doMax(maximum)
if default is not False:
self.doDefault(default)
guiFactory.warning("'%s.%s' converted to '%s'"%(self.obj.nameShort,self.attr,attrType))
"""except:
guiFactory.warning("'%s.%s' failed to convert"%(self.obj.nameShort,self.attr))"""
def set(self,value,*a, **kw):
"""
Set attr value based on attr type
Keyword arguments:
value(varied)
*a, **kw
"""
try:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for i,c in enumerate(self.children):
try:
cInstance = AttrFactory(self.obj.nameShort,c)
if type(value) is list and len(self.children) == len(value): #if we have the same length of values in our list as we have children, use them
attributes.doSetAttr(cInstance.obj.nameShort,cInstance.attr, value[i], *a, **kw)
cInstance.value = value[i]
self.value = value
else:
attributes.doSetAttr(cInstance.obj.nameShort,cInstance.attr, value, *a, **kw)
self.value = value
except:
guiFactory.warning("'%s' failed to set"%c)
elif self.form == 'message':
if value:
self.doStore(value)
else:
attributes.doSetAttr(self.obj.nameShort,self.attr, value, *a, **kw)
self.value = value
except:
guiFactory.warning("'%s.%s' failed to set '%s'"%(self.obj.nameShort,self.attr,value))
def get(self,*a, **kw):
"""
Get and store attribute value based on attr type
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(self.obj.nameShort,self.attr)
else:
self.value = attributes.doGetAttr(self.obj.nameShort,self.attr)
#guiFactory.report("'%s.%s' >> '%s'"%(self.obj.nameShort,self.attr,self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get"%(self.obj.nameShort,self.attr))
def getMessage(self,*a, **kw):
"""
Get and store attribute value as if they were messages. Used for bufferFactory to use a connected
attribute as a poor man's attribute message function
Keyword arguments:
*a, **kw
"""
try:
if self.form == 'message':
self.value = attributes.returnMessageObject(self.obj.nameShort,self.attr)
if search.returnObjectType(self.value) == 'reference':
if attributes.repairMessageToReferencedTarget(self.obj.nameLong,self.attr,*a,**kw):
self.value = attributes.returnMessageObject(self.obj.nameShort,self.attr)
else:
self.value = attributes.returnDriverAttribute("%s.%s"%(self.obj.nameShort,self.attr))
guiFactory.report("'%s.%s' >Message> '%s'"%(self.obj.nameShort,self.attr,self.value))
return self.value
except:
guiFactory.warning("'%s.%s' failed to get"%(self.obj.nameShort,self.attr))
def setEnum(self,enumCommand):
"""
Set the options for an enum attribute
Keyword arguments:
enumCommand(string) -- 'off:on', 'off=0:on=2', etc
"""
try:
if self.form == 'enum':
mc.addAttr ((self.obj.nameShort+'.'+self.attr), e = True, at= 'enum', en = enumCommand)
self.enum = enumCommand
guiFactory.report("'%s.%s' has been updated!"%(self.obj.nameShort,self.attr))
else:
guiFactory.warning("'%s.%s' is not an enum. Invalid call"%(self.obj.nameShort,self.attr))
except:
guiFactory.warning("'%s.%s' failed to change..."%(self.obj.nameShort,self.attr))
def doStore(self,infoToStore,convertIfNecessary = True):
"""
Store information to an object. If the info exits as an object, it stores as a message node. Otherwise there are
other storing methods.
Keyword arguments:
infoToStore(string) -- string of information to store
convertIfNecessary(bool) -- whether to convert the attribute if it needs to to store it. Default (True)
"""
assert self.children is False,"This attribute has children. Can't store."
try:
if self.form == 'message':
self.obj.store(self.attr,infoToStore)
self.value = infoToStore
elif convertIfNecessary:
self.doConvert('message')
self.updateData()
self.obj.store(self.attr,infoToStore)
self.value = infoToStore
except:
guiFactory.warning("'%s.%s' failed to store '%s'"%(self.obj.nameShort,self.attr,infoToStore))
def doDelete(self):
"""
Deletes an attribute
"""
try:
attributes.doDeleteAttr(self.obj.nameShort,self.attr)
guiFactory.warning("'%s.%s' deleted"%(self.obj.nameShort,self.attr))
self.value = None
return self.value
except:
guiFactory.warning("'%s.%s' failed to delete"%(self.obj.nameShort,self.attr))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Set Options
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def doDefault(self,value = None):
"""
Set default settings of an attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric:
if value is not None:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
try:
mc.addAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,defaultValue = value)
cInstance.defaultValue = value
except:
guiFactory.warning("'%s' failed to set a default value"%cInstance.nameCombined)
self.defaultValue = value
else:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,defaultValue = value)
self.defaultValue = value
except:
guiFactory.warning("'%s.%s' failed to set a default value"%(self.obj.nameShort,self.attr))
def doMax(self,value = None):
"""
Set max value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,hasMaxValue = value)
self.maxValue = value
guiFactory.warning("'%s.%s' had it's max value cleared"%(self.obj.nameShort,self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a max value"%(self.obj.nameShort,self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,maxValue = value)
self.maxValue = value
except:
guiFactory.warning("'%s.%s' failed to set a max value"%(self.obj.nameShort,self.attr))
def doMin(self,value = None):
"""
Set min value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,hasMinValue = value)
self.minValue = value
guiFactory.warning("'%s.%s' had it's min value cleared"%(self.obj.nameShort,self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a min value"%(self.obj.nameShort,self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,minValue = value)
self.minValue = value
except:
guiFactory.warning("'%s.%s' failed to set a default value"%(self.obj.nameShort,self.attr))
def doSoftMax(self,value = None):
"""
Set soft max value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,hasSoftMaxValue = 0)
self.softMaxValue = value
guiFactory.warning("'%s.%s' had it's soft max value cleared"%(self.obj.nameShort,self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a soft max value"%(self.obj.nameShort,self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,softMaxValue = value)
self.softMaxValue = value
except:
guiFactory.warning("'%s.%s' failed to set a soft max value"%(self.obj.nameShort,self.attr))
def doSoftMin(self,value = None):
"""
Set soft min value for a numeric attribute
Keyword arguments:
value(string) -- value or False to reset
"""
if self.numeric and not self.children:
if value is False:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,hasSoftMinValue = 0)
self.softMinValue = value
guiFactory.warning("'%s.%s' had it's soft max value cleared"%(self.obj.nameShort,self.attr))
except:
guiFactory.warning("'%s.%s' failed to clear a soft max value"%(self.obj.nameShort,self.attr))
elif value is not None:
try:
mc.addAttr((self.obj.nameShort+'.'+self.attr),e=True,softMinValue = value)
self.softMinValue = value
except:
guiFactory.warning("'%s.%s' failed to set a soft max value"%(self.obj.nameShort,self.attr))
def doLocked(self,arg = True):
"""
Set lock state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if not cInstance.locked:
mc.setAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,lock = True)
guiFactory.report("'%s.%s' locked!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.locked = True
self.updateData()
elif not self.locked:
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,lock = True)
guiFactory.report("'%s.%s' locked!"%(self.obj.nameShort,self.attr))
self.locked = True
else:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if cInstance.locked:
mc.setAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,lock = False)
guiFactory.report("'%s.%s' unlocked!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.locked = False
self.updateData()
elif self.locked:
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,lock = False)
guiFactory.report("'%s.%s' unlocked!"%(self.obj.nameShort,self.attr))
self.locked = False
def doHidden(self,arg = True):
"""
Set hidden state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if not cInstance.hidden:
if cInstance.keyable:
cInstance.doKeyable(False)
mc.setAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,channelBox = False)
guiFactory.report("'%s.%s' hidden!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.hidden = False
elif not self.hidden:
if self.keyable:
self.doKeyable(False)
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,channelBox = False)
guiFactory.report("'%s.%s' hidden!"%(self.obj.nameShort,self.attr))
self.hidden = True
else:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if cInstance.hidden:
mc.setAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,channelBox = True)
guiFactory.report("'%s.%s' unhidden!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.hidden = False
elif self.hidden:
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,channelBox = True)
guiFactory.report("'%s.%s' unhidden!"%(self.obj.nameShort,self.attr))
self.hidden = False
def doKeyable(self,arg = True):
"""
Set keyable state of an attribute
Keyword arguments:
arg(bool)
"""
assert type(arg) is bool, "doLocked arg must be a bool!"
if arg:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if not cInstance.keyable:
mc.setAttr(cInstance.nameCombined,e=True,keyable = True)
guiFactory.report("'%s.%s' keyable!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.keyable = True
cInstance.hidden = False
elif not self.keyable:
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,keyable = True)
guiFactory.report("'%s.%s' keyable!"%(self.obj.nameShort,self.attr))
self.keyable = True
self.hidden = False
else:
if self.children:
guiFactory.warning("'%s' has children, running set command on '%s'"%(self.nameCombined,"','".join(self.children)))
for c in self.children:
cInstance = AttrFactory(self.obj.nameShort,c)
if cInstance.keyable:
mc.setAttr((cInstance.obj.nameShort+'.'+cInstance.attr),e=True,keyable = False)
guiFactory.report("'%s.%s' unkeyable!"%(cInstance.obj.nameShort,cInstance.attr))
cInstance.keyable = False
if not mc.getAttr(cInstance.nameCombined,channelBox=True):
cInstance.updateData()
cInstance.doHidden(False)
elif self.keyable:
mc.setAttr((self.obj.nameShort+'.'+self.attr),e=True,keyable = False)
guiFactory.report("'%s.%s' unkeyable!"%(self.obj.nameShort,self.attr))
self.keyable = False
if not mc.getAttr(self.nameCombined,channelBox=True):
self.updateData()
self.doHidden(False)
def doAlias(self,arg):
"""
Set the alias of an attribute
Keyword arguments:
arg(string) -- name you want to use as an alias
"""
assert type(arg) is str or unicode,"Must pass string argument into doAlias"
if arg:
try:
if arg != self.nameAlias:
if mc.aliasAttr(arg,self.nameCombined):
self.nameAlias = arg
else:
guiFactory.report("'%s.%s' already has that alias!"%(self.obj.nameShort,self.attr,arg))
except:
guiFactory.warning("'%s.%s' failed to set alias of '%s'!"%(self.obj.nameShort,self.attr,arg))
else:
if self.nameAlias:
self.attr = self.nameLong
mc.aliasAttr(self.nameCombined,remove=True)
self.nameAlias = False
self.updateData()
def doNiceName(self,arg):
"""
Set the nice name of an attribute
Keyword arguments:
arg(string) -- name you want to use as a nice name
"""
assert type(arg) is str or unicode,"Must pass string argument into doNiceName"
if arg:
try:
mc.addAttr(self.nameCombined,edit = True, niceName = arg)
self.nameNice = arg
except:
guiFactory.warning("'%s.%s' failed to set nice name of '%s'!"%(self.obj.nameShort,self.attr,arg))
def doRename(self,arg):
"""
Rename an attribute as something else
Keyword arguments:
arg(string) -- name you want to use as a nice name
"""
assert type(arg) is str or unicode,"Must pass string argument into doRename"
if arg:
try:
if arg != self.nameLong:
attributes.doRenameAttr(self.obj.nameShort,self.nameLong,arg)
self.attr = arg
self.updateData()
else:
guiFactory.report("'%s.%s' already has that nice name!"%(self.obj.nameShort,self.attr,arg))
except:
guiFactory.warning("'%s.%s' failed to rename name of '%s'!"%(self.obj.nameShort,self.attr,arg))
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Connections and transfers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
def returnCompatibleFromTarget(self,target,*a, **kw):
"""
Attempts to make a connection from instanced attribute to a target
Keyword arguments:
target(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(target),"'%s' doesn't exist"%target
return attributes.returnCompatibleAttrs(self.obj.nameShort,self.nameLong,target,*a, **kw)
def doConnectOut(self,target,*a, **kw):
"""
Attempts to make a connection from instanced attribute to a target
Keyword arguments:
target(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(target),"'%s' doesn't exist"%target
if '.' in target:
try:
attributes.doConnectAttr(self.nameCombined,target)
except:
guiFactory.warning("'%s' failed to connect to '%s'!"%(self.nameCombined,target))
else:
#If the object has a transform
matchAttr = attributes.returnMatchNameAttrsDict(self.obj.nameShort,target,[self.nameLong]) or []
if matchAttr:
#If it has a matching attribute
try:
attributes.doConnectAttr(self.nameCombined,('%s.%s'%(target,matchAttr.get(self.nameLong))))
except:
guiFactory.warning("'%s' failed to connect to '%s'!"%(self.nameCombined,target))
else:
print "Target object doesn't have this particular attribute"
def doConnectIn(self,source,*a, **kw):
"""
Attempts to make a connection from a source to our instanced attribute
Keyword arguments:
source(string) - object or attribute to connect to
*a, **kw
"""
assert mc.objExists(source),"'%s' doesn't exist"%source
if '.' in source:
try:
attributes.doConnectAttr(source,self.nameCombined)
except:
guiFactory.warning("'%s' failed to connect to '%s'!"%(source,self.nameCombined))
else:
#If the object has a transform
matchAttr = attributes.returnMatchNameAttrsDict(self.obj.nameShort,source,[self.nameLong]) or []
if matchAttr:
#If it has a matching attribute
try:
attributes.doConnectAttr(('%s.%s'%(source,matchAttr.get(self.nameLong))),self.nameCombined)
except:
guiFactory.warning("'%s' failed to connect to '%s'!"%(source,self.nameCombined))
else:
print "Source object doesn't have this particular attribute"
def doCopyTo(self,target, targetAttrName = None, debug = True,*a,**kw):
"""
Replacement for Maya's since maya's can't handle shapes....blrgh...
Copy attributes from one object to another as well as other options. If the attribute already
exists, it'll copy the values. If it doesn't, it'll make it. If it needs to convert, it can.
It will not make toast.
Keywords:
toObject(string) - obj to copy to
targetAttrName(string) -- name of the attr to copy to . Default is None which will create an
attribute oft the fromAttr name on the toObject if it doesn't exist
convertToMatch(bool) -- whether to convert if necessary.default True
values(bool) -- copy values. default True
incomingConnections(bool) -- default False
outGoingConnections(bool) -- default False
keepSourceConnections(bool)-- keeps connections on source. default True
copyAttrSettings(bool) -- copy the attribute state of the fromAttr (keyable,lock,hidden). default True
connectSourceToTarget(bool) useful for moving attribute controls to another object. default False
RETURNS:
success(bool)
"""
assert mc.objExists(target),"'%s' doesn't exist"%target
assert mc.ls(target,long=True) != [self.obj.nameShort], "Can't transfer to self!"
functionName = 'doCopyTo'
convertToMatch = kw.pop('convertToMatch',True)
values = kw.pop('values',True)
incomingConnections = kw.pop('incomingConnections',False)
outgoingConnections = kw.pop('outgoingConnections',False)
keepSourceConnections = kw.pop('keepSourceConnections',True)
copyAttrSettings = kw.pop('copyAttrSettings',True)
connectSourceToTarget = kw.pop('connectSourceToTarget',False)
connectTargetToSource = kw.pop('connectTargetToSource',False)
if debug:
guiFactory.doPrintReportStart(functionName)
guiFactory.report("AttrFactory instance: '%s'"%self.nameCombined)
guiFactory.report("convertToMatch: '%s'"%convertToMatch)
guiFactory.report("targetAttrName: '%s'"%targetAttrName)
guiFactory.report("incomingConnections: '%s'"%incomingConnections)
guiFactory.report("outgoingConnections: '%s'"%outgoingConnections)
guiFactory.report("keepSourceConnections: '%s'"%keepSourceConnections)
guiFactory.report("copyAttrSettings: '%s'"%copyAttrSettings)
guiFactory.report("connectSourceToTarget: '%s'"%connectSourceToTarget)
guiFactory.report("keepSourceConnections: '%s'"%keepSourceConnections)
guiFactory.report("connectTargetToSource: '%s'"%connectTargetToSource)
guiFactory.doPrintReportBreak()
copyTest = [values,incomingConnections,outgoingConnections,keepSourceConnections,connectSourceToTarget,copyAttrSettings]
if sum(copyTest) < 1:
guiFactory.warning("You must have at least one option for copying selected. Otherwise, you're looking for the 'doDuplicate' function.")
return False
if '.' in list(target):
targetBuffer = target.split('.')
if len(targetBuffer) == 2:
attributes.doCopyAttr(self.obj.nameShort,
self.nameLong,
targetBuffer[0],
targetBuffer[1],
convertToMatch = convertToMatch,
values=values, incomingConnections = incomingConnections,
outgoingConnections=outgoingConnections, keepSourceConnections = keepSourceConnections,
copyAttrSettings = copyAttrSettings, connectSourceToTarget = connectSourceToTarget)
else:
guiFactory.warning("Yeah, not sure what to do with this. Need an attribute call with only one '.'")
else:
attributes.doCopyAttr(self.obj.nameShort,
self.nameLong,
target,
targetAttrName,
convertToMatch = convertToMatch,
values=values, incomingConnections = incomingConnections,
outgoingConnections=outgoingConnections, keepSourceConnections = keepSourceConnections,
copyAttrSettings = copyAttrSettings, connectSourceToTarget = connectSourceToTarget)
if debug:
guiFactory.doPrintReportEnd(functionName)
#except:
# guiFactory.warning("'%s' failed to copy to '%s'!"%(target,self.nameCombined))
def doTransferTo(self,target):
"""
Transfer an instanced attribute to a target with all settings and connections intact
Keyword arguments:
target(string) -- object to transfer it to
*a, **kw
"""
assert mc.objExists(target),"'%s' doesn't exist"%target
assert mc.ls(target,type = 'transform',long = True),"'%s' Doesn't have a transform"%target
assert self.obj.transform is not False,"'%s' Doesn't have a transform. Transferring this attribute is probably a bad idea. Might we suggest doCopyTo along with a connect to source option"%self.obj.nameShort
assert mc.ls(target,long=True) != [self.obj.nameShort], "Can't transfer to self!"
assert '.' not in list(target),"'%s' appears to be an attribute. Can't transfer to an attribute."%target
assert self.dynamic is True,"'%s' is not a dynamic attribute."%self.nameCombined
#mc.copyAttr(self.obj.nameShort,self.target.obj.nameShort,attribute = [self.target.attr],v = True,ic=True,oc=True,keepSourceConnections=True)
attributes.doCopyAttr(self.obj.nameShort,
self.nameLong,
target,
self.nameLong,
convertToMatch = True,
values = True, incomingConnections = True,
outgoingConnections = True, keepSourceConnections = False,
copyAttrSettings = True, connectSourceToTarget = False)
self.doDelete()
