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 purgeBuffer(objectBufferName):
tmp = BufferFactory(objectBufferName)
tmp.purge()
def createBuffer(self):
b = BufferFactory('Buffer')
b.doStoreSelected()
self.reset()
def keyBuffer(objectBufferName):
tmp = BufferFactory(objectBufferName)
tmp.key()
def removeSelected(objectBufferName):
tmp = BufferFactory(objectBufferName)
tmp.doRemoveSelected()
def addSelected(objectBufferName):
tmp = BufferFactory(objectBufferName)
tmp.doStoreSelected()
def selectBufferObjects(objectBufferName):
tmp = BufferFactory(objectBufferName)
tmp.select()
def makeLimbTemplate (self):
#>>>Curve degree finder
if self.optionCurveDegree.get() == 0:
doCurveDegree = 1
else:
if len(corePositionList) <= 3:
doCurveDegree = 1
else:
doCurveDegree = len(corePositionList) - 1
#Make some storage vehicles
self.templatePosObjectsBuffer = BufferFactory(self.infoNulls['templatePosObjects'].get())
self.templatePosObjectsBuffer.purge()
LocatorCatcher = ObjectFactory('')
LocatorBuffer = BufferFactory(LocatorCatcher.nameLong)
LocatorBuffer.purge()
returnList = []
self.templHandleList = []
moduleColors = modules.returnModuleColors(self.ModuleNull.nameShort)
#>>>Scale stuff
moduleParent = self.msgModuleParent.get()
if not moduleParent:
length = (distance.returnDistanceBetweenPoints (corePositionList[0],corePositionList[-1]))
size = length / self.optionHandles.get()
else:
#>>>>>>>>>>>>>>>>>>>>> NOT TOUCHED YET
parentTemplatePosObjectsInfoNull = modules.returnInfoTypeNull(moduleParent,'templatePosObjects')
parentTemplatePosObjectsInfoData = attributes.returnUserAttrsToDict (parentTemplatePosObjectsInfoNull)
parentTemplateObjects = []
for key in parentTemplatePosObjectsInfoData.keys():
if (mc.attributeQuery (key,node=parentTemplatePosObjectsInfoNull,msg=True)) == True:
if search.returnTagInfo((parentTemplatePosObjectsInfoData[key]),'cgmType') != 'templateCurve':
parentTemplateObjects.append (parentTemplatePosObjectsInfoData[key])
createBuffer = curves.createControlCurve('sphere',1)
pos = corePositionList[0]
mc.move (pos[0], pos[1], pos[2], createBuffer, a=True)
closestParentObject = distance.returnClosestObject(createBuffer,parentTemplateObjects)
boundingBoxSize = distance.returnBoundingBoxSize (closestParentObject)
maxSize = max(boundingBoxSize)
size = maxSize *.25
mc.delete(createBuffer)
if partType == 'clavicle':
size = size * .5
elif partType == 'head':
size = size * .75
if (search.returnTagInfo(moduleParent,'cgmModuleType')) == 'clavicle':
size = size * 2
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Making the template objects
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.TemplateObject = {}
#>>> Template objects
for cnt,pos in enumerate(corePositionList):
#Size multiplier based on PuppetMode, make it take into account module mode eventually
if PuppetInstance.optionPuppetMode.get() == 0:
if cnt == 0:
sizeMultiplier = 1
elif cnt == len(corePositionList) -1:
sizeMultiplier = .8
else:
sizeMultiplier = .5
else:
sizeMultiplier = 1
#make a sphere and move it
createBuffer = curves.createControlCurve('sphere',(size * sizeMultiplier))
self.TemplateObject[cnt] = ObjectFactory(createBuffer) # Instance the control to our module
obj = self.TemplateObject[cnt]
curves.setCurveColorByName(obj.nameLong,moduleColors[0])
obj.store('cgmName',coreNames[cnt])
obj.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmName','cgmType'])
obj.store('cgmType','templateObject')
obj.doName()
mc.move (pos[0], pos[1], pos[2], [obj.nameLong], a=True)
#adds it to the list
self.templHandleList.append (obj.nameLong)
self.templatePosObjectsBuffer.store(obj.nameLong)
#Aim the objects
position.aimObjects(self.templHandleList,
dictionary.axisDirectionsByString[ self.optionAimAxis.get() ],
dictionary.axisDirectionsByString[ self.optionUpAxis.get() ],
dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ])
#>>> Template curve
crvName = mc.curve (d=doCurveDegree, p = corePositionList , os=True, n=('%s_%s' %(partName,(typesDictionary.get('templateCurve')))))
self.afTemplateCurve = AttrFactory(self.infoNulls['templatePosObjects'].get(),
'curve','message', value=crvName)# connect it back to our template objects info null
curve = ObjectFactory(crvName) # instance it
curve.getNameTagsFromObject(self.ModuleNull.nameLong,['cgmType']) #get name tags from the module
attributes.storeInfo(crvName,'cgmType','templateCurve') # store type
curves.setCurveColorByName(crvName,moduleColors[1]) # set curve color
# Make locators to connect the cv's to
for cnt,obj in enumerate(self.templHandleList):
pointLoc = locators.locMeObject(obj) # make the loc
loc = ObjectFactory(pointLoc) #instance it
mc.setAttr ((loc.nameShort+'.visibility'),0) # turn off visibility
mc.parentConstraint ([obj],[loc.nameShort],mo=False) # parent constrain
mc.connectAttr ( (loc.nameShort+'.translate'),
('%s.controlPoints[%i]' % (crvName, cnt)), f=True ) # connect the cv to the loc
self.TemplateObject[cnt].store('loc',loc.nameLong)
LocatorBuffer.store(loc.nameLong)
#>>> Direction and size Stuff
"""
# Directional data derived from joints
generalDirection = logic.returnHorizontalOrVertical(self.templHandleList)
if generalDirection == 'vertical' and 'leg' not in self.afModuleType.get():
worldUpVector = [0,0,-1]
elif generalDirection == 'vertical' and 'leg' in self.afModuleType.get():
worldUpVector = [0,0,1]
else:
worldUpVector = [0,1,0]
"""
# Create root control
templateNull = self.msgTemplateNull.get()
handleList = copy.copy(self.templatePosObjectsBuffer.bufferList)
rootSize = (distance.returnBoundingBoxSizeToAverage(self.templHandleList[0])*1.5)
rootCtrl = ObjectFactory(curves.createControlCurve('cube',rootSize))
rootCtrl.getNameTagsFromObject(self.ModuleNull.nameLong)
self.msgTemplateRoot = AttrFactory(self.infoNulls['templatePosObjects'].get(), 'root', 'message', value = rootCtrl.nameLong)
curves.setCurveColorByName(rootCtrl.nameLong,moduleColors[0])
# move the root
if self.afModuleType.get() == 'clavicle':
position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0])
else:
position.movePointSnap(rootCtrl.nameLong,self.templHandleList[0])
# aim the root
position.aimSnap(rootCtrl.nameShort,self.templHandleList[-1],
dictionary.axisDirectionsByString[ self.optionAimAxis.get() ],
dictionary.axisDirectionsByString[ self.optionUpAxis.get() ],
dictionary.axisDirectionsByString[ PuppetInstance.optionUpAxis.get() ])
rootCtrl.store('cgmType','templateRoot')
rootCtrl.doName()
#>>> Parent the main objcts
rootGroup = rootCtrl.doGroup()
rootGroup = rigging.doParentReturnName(rootGroup,templateNull)
curve.doParent(templateNull)
for obj in LocatorBuffer.bufferList:
rigging.doParentReturnName(obj,templateNull)
mc.delete(LocatorCatcher.nameShort) # delete the locator buffer obj
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Orientation helpers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Make our Orientation Helpers
"""
orientHelpersReturn = template.addOrientationHelpers(self)
masterOrient = orientHelpersReturn[0]
orientObjects = orientHelpersReturn[1]
return
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Control helpers
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
print orientObjects
print self.ModuleNull.nameShort
print (templateNull+'.visControlHelpers')
controlHelpersReturn = addControlHelpers(orientObjects,self.ModuleNull.nameShort,(templateNull+'.visControlHelpers'))"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Input the saved values if there are any
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Orientation Helpers
"""rotBuffer = coreRotationList[-1]
#actualName = mc.spaceLocator (n= wantedName)
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],masterOrient,os=True)
cnt = 0
for obj in orientObjects:
rotBuffer = coreRotationList[cnt]
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,os=True)
cnt +=1
# Control Helpers
controlHelpers = controlHelpersReturn[0]
cnt = 0
for obj in controlHelpers:
posBuffer = controlPositionList[cnt]
posCheck = sum(posBuffer)
if posCheck != 0:
mc.xform(obj,t=[posBuffer[0],posBuffer[1],posBuffer[2]],ws=True)
rotBuffer = controlRotationList[cnt]
rotCheck = sum(rotBuffer)
if rotCheck != 0:
mc.rotate(rotBuffer[0],rotBuffer[1],rotBuffer[2],obj,ws=True)
scaleBuffer = controlScaleList[cnt]
scaleCheck = sum(scaleBuffer)
if scaleCheck != 0:
mc.scale(scaleBuffer[0],scaleBuffer[1],scaleBuffer[2],obj,absolute=True)
cnt +=1 """
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#>> Final stuff
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
returnList.append(templObjNameList)
returnList.append(self.templHandleList)
returnList.append(rootCtrl)"""
return True
