def ObjectFacesToFolicles():
try:
import parentConstraintToSurface
except:
"Can't find parentConstraintToSurface"
selection = mc.ls(sl=True) or []
if not selection:
return "Nothing selected"
#If we're going, create a return set
returnSet = SetFactory.SetFactory('folicledLocs', 'td', True)
# Make some groups
mLocGroup = mc.group(em=True, name='locators_grp')
number = len(selection)
returnList = []
for i, o in enumerate(selection):
guiFactory.report("On %s. %s of %s" % (o, i, number))
faceBuffer = "%s.f[4]" % o
if not mc.objExists(faceBuffer):
print "'%s' has no face!" % o
loc = locators.locMeObject(faceBuffer)
returnSet.store(loc)
mc.select(cl=True)
mc.select(loc, o)
parentConstraintToSurface.parentConstraintToSurface()
rigging.doParentReturnName(loc, mLocGroup)
follicles = mc.ls(type='follicle')
mc.select(follicles)
mc.group(name='folicles_grp')
def doParent(self,p = False):
"""
Function for parenting a maya instanced object while maintaining a correct object instance.
Keyword arguments:
p(string) -- Whether to run a full scene dictionary check or the faster just objExists check
"""
assert self.transform,"'%s' has no transform"%obj
if p: #if we have a target parent
try:
#If we have an Object Factory instance, link it
p.nameShort
p = p.nameShort
except:
#If it fails, check that the object name exists and if so, initialize a new Object Factory instance
assert mc.objExists(p) is True, "'%s' - parent object doesn't exist" %p
buffer = rigging.doParentReturnName(self.nameLong,p)
else:#If not, do so to world
buffer = rigging.doParentToWorld(self.nameLong)
self.update(buffer)
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 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 orientSkeletonTemplate():
#First unparent the parts so we can orient properly
hip = rigging.doParentToWorld('hip_l')
heel = rigging.doParentToWorld('heel_l')
clav = rigging.doParentToWorld('clavicle_l')
palm = rigging.doParentToWorld('palm_l')
spineChain = ['root']
spineChain.extend(search.returnChildrenJoints('root'))
for j in spineChain:
joints.orientJoint(j, 'xzy', 'zup')
hipChain = [hip]
hipChain.extend(search.returnChildrenJoints(hip))
for j in hipChain:
#joints.orientJoint(j,'xzy','zup')
joints.orientJoint(j, 'xzy', 'zup')
armChain = [clav]
armChain.extend(search.returnChildrenJoints(clav))
for j in armChain:
joints.orientJoint(j, 'xyz', 'yup')
footChain = [heel]
footChain.extend(search.returnChildrenJoints(heel))
for j in footChain:
#joints.orientJoint(j,'yzx','yup')
#joints.orientJoint(j,'xyz','yup')
joints.orientJoint(j, 'zyx', 'yup')
handChain = [palm]
handChain.extend(search.returnChildrenJoints(palm))
for j in handChain:
joints.orientJoint(j, 'xzy', 'zup')
#Fix the thumb
thumbChain = ['thumb1_l']
thumbChain.extend(search.returnChildrenJoints('thumb1_l'))
for j in thumbChain:
#tweak - taken from Comet's orient
mc.xform(j, r=True, os=True, ra=(-20, 0, 0))
mc.joint(j, e=True, zso=True)
mc.makeIdentity(j, apply=True)
#Fix the Head
headChain = ['head1']
headChain.extend(search.returnChildrenJoints('head1'))
for j in headChain:
joints.orientJoint(j, 'yzx', 'zup')
#Reconnect
rigging.doParentReturnName(hip, 'root')
rigging.doParentReturnName(clav, 'spine5')
rigging.doParentReturnName(heel, 'ankle_l')
rigging.doParentReturnName(palm, 'wrist_l')
return spineChain
def orientSkeletonTemplate():
#First unparent the parts so we can orient properly
hip = rigging.doParentToWorld('hip_l')
heel = rigging.doParentToWorld('heel_l')
clav = rigging.doParentToWorld('clavicle_l')
palm = rigging.doParentToWorld('palm_l')
spineChain = ['root']
spineChain.extend(search.returnChildrenJoints('root'))
for j in spineChain:
joints.orientJoint(j,'xzy','zup')
hipChain = [hip]
hipChain.extend(search.returnChildrenJoints(hip))
for j in hipChain:
#joints.orientJoint(j,'xzy','zup')
joints.orientJoint(j,'xzy','zup')
armChain = [clav]
armChain.extend(search.returnChildrenJoints(clav))
for j in armChain:
joints.orientJoint(j,'xyz','yup')
footChain = [heel]
footChain.extend(search.returnChildrenJoints(heel))
for j in footChain:
#joints.orientJoint(j,'yzx','yup')
#joints.orientJoint(j,'xyz','yup')
joints.orientJoint(j,'zyx','yup')
handChain = [palm]
handChain.extend(search.returnChildrenJoints(palm))
for j in handChain:
joints.orientJoint(j,'xzy','zup')
#Fix the thumb
thumbChain = ['thumb1_l']
thumbChain.extend(search.returnChildrenJoints('thumb1_l'))
for j in thumbChain:
#tweak - taken from Comet's orient
mc.xform(j,r=True,os=True,ra= (-20,0,0))
mc.joint(j,e=True,zso = True)
mc.makeIdentity(j,apply=True)
#Fix the Head
headChain = ['head1']
headChain.extend(search.returnChildrenJoints('head1'))
for j in headChain:
joints.orientJoint(j,'yzx','zup')
#Reconnect
rigging.doParentReturnName(hip,'root')
rigging.doParentReturnName(clav,'spine5')
rigging.doParentReturnName(heel,'ankle_l')
rigging.doParentReturnName(palm,'wrist_l')
return spineChain
def _fncStep_parenting_(self):
"""
"""
_mi_headMasterAnim = self.md_objs['headMasterAnim']
_mi_bodyMasterAnim = self.md_objs['BodyPuppet'].masterControl
_mi_bodyPuppet = self.md_objs['BodyPuppet']
_mi_headPuppet = self.md_objs['headPuppet']
try:#Geo --------------------------------------------------------------------
for mObj in _mi_headPuppet.masterNull.geoGroup.getChildren(asMeta = True):
mObj.parent = _mi_bodyPuppet.masterNull.geoGroup
except Exception,error:raise Exception,"Geo | error: {0}".format(error)
try:#Face Rig/gui --------------------------------------------------------------------
for k in ['faceGui','faceCam']:
rigging.doParentReturnName(self.md_objs[k].mNode, _mi_bodyPuppet.masterNull.noTransformGroup.mNode)
except Exception,error:raise Exception,"Face Rig/GUI | error: {0}".format(error)
try:#to Master control --------------------------------------------------------------------
for k in ['world_eyeLook','world_leftEye','world_rightEye','SDKface','SDKcustomize']:
rigging.doParentReturnName(self.md_objs[k].mNode, _mi_bodyMasterAnim.mNode)
except Exception,error:raise Exception,"...to master Control | error: {0}".format(error)
try:#Skeleton --------------------------------------------------------------------
rigging.doParentReturnName(self.md_objs['joint_faceRigHead'].mNode, self.md_objs['joint_bodyHead'].mNode)
except Exception,error:raise Exception,"...to master Control | error: {0}".format(error)
try:#Object Sets --------------------------------------------------------------------
_mi_bodyPuppet = self.md_objs['BodyPuppet']
for k in ['l_eyeModule','r_eyeModule','headModule']:
_mi_bodyPuppet.puppetSet.addObj(self.md_objs[k].rigNull.moduleSet.mNode)
except Exception,error:raise Exception,"...to master Control | error: {0}".format(error)
def skeletonizeCharacter(masterNull):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Skeletonizes a character
ARGUMENTS:
masterNull(string)
RETURNS:
nothin
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
modules = modules.returnModules(masterNull)
orderedModules = modules.returnOrderedModules(modules)
#>>> Do the spine first
stateCheck = modules.moduleStateCheck(orderedModules[0], ['template'])
if stateCheck == 1:
spineJoints = skeletonize(orderedModules[0])
else:
print('%s%s' %
(module, ' has already been skeletonized. Moving on...'))
#>>> Do the rest
for module in orderedModules[1:]:
stateCheck = modules.moduleStateCheck(module, ['template'])
if stateCheck == 1:
templateNull = modules.returnTemplateNull(module)
root = modules.returnInfoNullObjects(module,
'templatePosObjects',
types='templateRoot')
#>>> See if our item has a non default anchor
anchored = storeTemplateRootParent(module)
if anchored == True:
anchor = attributes.returnMessageObject(
root[0], 'skeletonParent')
closestJoint = distance.returnClosestObject(
anchor, spineJoints)
else:
closestJoint = distance.returnClosestObject(
root[0], spineJoints)
limbJoints = skeletonize(module)
rootName = rigging.doParentReturnName(limbJoints[0], closestJoint)
print rootName
else:
print('%s%s' %
(module, ' has already been skeletonized. Moving on...'))
def ObjectFacesToFolicles():
try:
import parentConstraintToSurface
except:
"Can't find parentConstraintToSurface"
selection = mc.ls(sl=True) or []
if not selection:
return "Nothing selected"
#If we're going, create a return set
returnSet = SetFactory.SetFactory('folicledLocs','td',True)
# Make some groups
mLocGroup = mc.group(em=True,name = 'locators_grp')
number = len(selection)
returnList = []
for i,o in enumerate(selection):
guiFactory.report("On %s. %s of %s"%(o,i,number))
faceBuffer = "%s.f[4]"%o
if not mc.objExists(faceBuffer):
print "'%s' has no face!"%o
loc = locators.locMeObject(faceBuffer)
returnSet.store(loc)
mc.select(cl=True)
mc.select(loc,o)
parentConstraintToSurface.parentConstraintToSurface()
rigging.doParentReturnName(loc,mLocGroup)
follicles = mc.ls(type='follicle')
mc.select(follicles)
mc.group(name = 'folicles_grp')
def returnAbsoluteSizeCurve(curve):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Pass an curve into it and it returns absolute distance scale
ARGUMENTS:
curve(string) - curve
RETURNS:
distances(list) - [xLength,yLength,zLength]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
def duplicateShape(shape):
parentObj = mc.listRelatives(shape, p=True, fullPath=True)
shapes = mc.listRelatives(parentObj, shapes=True, fullPath=True)
matchObjName = mc.ls(shape, long=True)
matchIndex = shapes.index(matchObjName[0])
dupBuffer = mc.duplicate(parentObj)
children = mc.listRelatives(dupBuffer[0], children = True, fullPath =True)
if len(children) > 0:
for c in children:
if search.returnObjectType(c) != 'shape':
mc.delete(c)
dupShapes = mc.listRelatives(dupBuffer[0], shapes=True, fullPath=True)
for shape in dupShapes:
if dupShapes.index(shape) != matchIndex:
mc.delete(shape)
return dupBuffer[0]
boundingBoxSize = returnBoundingBoxSize(curve)
if mayaVersion <=2010:
return boundingBoxSize
else:
distanceToMove = max(boundingBoxSize)
positions = []
isShape = False
if search.returnObjectType(curve) == 'shape':
dupCurve = duplicateShape(curve)
curve = dupCurve
isShape = True
loc = rigging.locMeObjectStandAlone(curve)
locGroup = rigging.groupMeObject(loc,False)
loc = rigging.doParentReturnName(loc,locGroup)
directions = ['x','y','z']
for direction in directions:
positionsBuffer = []
mc.setAttr((loc+'.t'+direction),distanceToMove)
positionsBuffer.append(returnClosestUPosition(loc,curve))
mc.setAttr((loc+'.t'+direction),-distanceToMove)
positionsBuffer.append(returnClosestUPosition(loc,curve))
mc.setAttr((loc+'.t'+direction),0)
positions.append(positionsBuffer)
distances = []
for set in positions:
distances.append(returnDistanceBetweenPoints(set[0],set[1]))
if isShape == True:
mc.delete(dupCurve)
mc.delete(locGroup)
return distances
def bakeBlendShapeNode(sourceObject, blendShapeNode, baseNameToUse = False, stripPrefix = False, ignoreInbetweens = False, ignoreTargets = False):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for exporting an object's blendshapes
ARGUMENTS:
targetObject(string)
sourceObject(string)
blendShapeNode(string) the node to bake from
baseName(bool/string) - if it's False, it uses the target Object name, else, it uses what is supplied
stripPrefix(bool) - whether to strip the first '_' segment
ignoreInbetweens(bool)
ignoreTargets(list) - targets to ignore in the processing
RETURNS:
Success(bool)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Prep
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" declare variables """
returnList = []
blendShapeNamesBaked = []
blendShapeConnections = []
currentConnections = []
""" base name """
if baseNameToUse == False:
baseName = ''
else:
baseName = baseNameToUse + '_'
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Meat of it
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
targetDict = returnBlendShapeTargetsAndWeights(sourceObject,blendShapeNode)
targetSets = []
blendShapeNodeChannels = []
for key in targetDict.keys():
targetSetBuffer = targetDict.get(key)
targetSets.append(targetSetBuffer)
baseSet = targetSetBuffer[-1]
blendShapeNodeChannels.append(baseSet[0])
blendShapeShortNames = []
""" first loop gets connections, breaks them and sets everything to 0 """
for shape in blendShapeNodeChannels:
blendShapeBuffer = (blendShapeNode+'.'+shape)
""" get the connection """
blendShapeConnections.append(attributes.returnDriverAttribute(blendShapeBuffer))
print blendShapeConnections
"""break it """
attributes.doBreakConnection(blendShapeBuffer)
attributes.doSetAttr(blendShapeBuffer,0)
# Bake it
bakedGeo = bakeBlendShapes(sourceObject, sourceObject, blendShapeNode, baseNameToUse, stripPrefix, ignoreInbetweens, ignoreTargets)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Finish out
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" restore connections """
for shape in blendShapeNodeChannels:
currentIndex = blendShapeNodeChannels.index(shape)
blendShapeBuffer = (blendShapeNode+'.'+shape)
""" Restore the connection """
if blendShapeConnections[currentIndex] != False:
attributes.doConnectAttr(blendShapeConnections[currentIndex],blendShapeBuffer)
""" group for geo """
meshGroup = mc.group( em=True)
if baseNameToUse != False:
attributes.storeInfo(meshGroup,'cgmName', baseNameToUse)
attributes.storeInfo(meshGroup,'cgmTypeModifier', 'blendShapeGeo')
meshGroup = NameFactory.doNameObject(meshGroup)
for geo in bakedGeo:
rigging.doParentReturnName(geo,meshGroup)
returnList.append(meshGroup)
returnList.append(bakedGeo)
return returnList
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
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
def doCreateStartingPositionLoc(self, modeType='child', workingObject=None, aimingObject=None, cvIndex = None ):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Adds a locator setup to duplicate to get our initial position locators. All should be zeroed out.
The top node of the return group has the loctor and move group connected is message nodes if needed.
ARGUMENTS:
modeType(string)
child - basic child locator to the workingObject
innerChild - aims locator from the working to the aiming curves
cvBack - works off working curves cvIndex. Places it and aiming
it back on z. Mainly used for tails
radialOut - Works off working curve cv for position and radial
orientation. It's transform group is oriented to
the aiming curves equivalent cv. Good for arms
radialDown - same as radial out but locator orientation is y down zup for legs.
transform orientation is the same as radial out
footBase - looking for it's module Parent's last loc to start from
parentDuplicate - looking for it's module Parent's last loc to start from
workingObject(string) - usually the sizing objects start curve (can be a locator for parentchild loc)
aimingObject(string) - usually the sizing objects end curve
cvIndex(int) - cv to work off of
RETURNS:
returnList(list) = [rootHelper(string),helperObjects(list),helperObjectGroups(list)]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
if modeType == 'child':
""" make initial loc and orient it """
returnLoc = []
curveShapes = mc.listRelatives(workingObject, shapes = True)
startLoc = locators.locMeObject(workingObject)
aimLoc = locators.locMeObject(workingObject)
upLoc = locators.locMeCvFromCvIndex(curveShapes[0],0)
startLoc = mc.rename(startLoc,(self.ModuleNull.nameBase+'child_startLoc'))
StartLoc = ObjectFactory(startLoc)
sizeObjectLength = distance.returnDistanceBetweenObjects(workingObject,aimingObject)
mc.xform(aimLoc,t=[0,0,sizeObjectLength],r=True,os=True)
aimConstraintBuffer = mc.aimConstraint(aimLoc,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpObject = upLoc, worldUpType = 'object' )
mc.delete(aimConstraintBuffer[0])
mc.delete(upLoc)
mc.delete(aimLoc)
zeroGroup = StartLoc.doGroup()
returnLoc.append(StartLoc.nameLong)
attributes.storeInfo(zeroGroup,'locator',startLoc)
returnLoc.append(zeroGroup)
return returnLoc
elif modeType == 'innerChild':
""" make initial lock and orient it """
returnLoc = []
curveShapes = mc.listRelatives(workingObject, shapes = True)
startLoc = locators.locMeObject(workingObject)
aimLoc = locators.locMeObject(aimingObject)
upLoc = locators.locMeCvFromCvIndex(curveShapes[0],0)
startLoc = mc.rename(startLoc, (self.ModuleNull.nameBase+'_innerChild_startLoc'))
StartLoc = ObjectFactory(startLoc)
aimConstraintBuffer = mc.aimConstraint(aimLoc,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpObject = upLoc, worldUpType = 'object' )
mc.delete(aimConstraintBuffer[0])
mc.delete(upLoc)
mc.delete(aimLoc)
zeroGroup = StartLoc.doGroup()
returnLoc.append(StartLoc.nameLong)
#zeroGroup = rigging.zeroTransformMeObject(startLoc)
#attributes.storeInfo(zeroGroup,'locator',startLoc)
returnLoc.append(zeroGroup)
return returnLoc
elif modeType == 'cvBack':
returnLoc = []
curveShapes = mc.listRelatives(workingObject, shapes = True)
startLoc = locators.locMeCvFromCvIndex(curveShapes[0],cvIndex)
upLoc = locators.locMeObject(workingObject)
initialAimLoc = locators.locMeObject(aimingObject)
aimConstraintBuffer = mc.aimConstraint(initialAimLoc,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,-1], upVector = [0,-1,0], worldUpObject = upLoc, worldUpType = 'object', skip = ['x','z'])
mc.delete(aimConstraintBuffer[0])
mc.delete(initialAimLoc)
aimLoc = locators.locMeCvFromCvIndex(curveShapes[0],cvIndex)
startLoc = mc.rename(startLoc, (self.ModuleNull.nameBase+'_radialBackl_startLoc'))
StartLoc = ObjectFactory(startLoc)
sizeObjectLength = distance.returnDistanceBetweenObjects(workingObject,aimingObject)
mc.xform(aimLoc,t=[0,0,-sizeObjectLength],r=True,ws=True)
aimConstraintBuffer = mc.aimConstraint(aimLoc,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpType = 'vector' )
mc.delete(aimConstraintBuffer[0])
mc.delete(aimLoc)
mc.delete(upLoc)
returnLoc.append(startLoc)
zeroGroup = StartLoc.doGroup()
returnLoc.append(StartLoc.nameLong)
return returnLoc
elif modeType == 'radialOut':
sizeObjectLength = distance.returnDistanceBetweenObjects(workingObject,aimingObject)
returnLoc = []
workingObjectShapes = mc.listRelatives(workingObject, shapes = True)
aimingObjectShapes = mc.listRelatives(aimingObject, shapes = True)
"""initial loc creation and orientation"""
startLoc = locators.locMeCvFromCvIndex(workingObjectShapes[0],cvIndex)
startLocAim = locators.locMeObject(workingObject)
startLocUp = locators.locMeCvFromCvIndex(workingObjectShapes[0],cvIndex)
startLoc = mc.rename(startLoc, (self.ModuleNull.nameBase+'_radialOut_startLoc'))
StartLoc = ObjectFactory(startLoc)
""" move the up loc up """
mc.xform(startLocUp,t=[0,sizeObjectLength,0],r=True,ws=True)
""" aim it """
aimConstraintBuffer = mc.aimConstraint(startLocAim,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,-1], upVector = [0,1,0], worldUpType = 'vector' )
mc.delete(aimConstraintBuffer[0])
mc.delete(startLocUp)
""" setup the transform group"""
transformGroup = rigging.groupMeObject(startLoc,False)
transformGroup = mc.rename(transformGroup,('%s%s' %(startLoc,'_moveGroup')))
groupUp = startLocAim
groupAim = locators.locMeCvFromCvIndex(aimingObjectShapes[0],cvIndex)
"""aim it"""
aimConstraintBuffer = mc.aimConstraint(groupAim,transformGroup,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,-1,0], worldUpObject = groupUp, worldUpType = 'object')
mc.delete(aimConstraintBuffer[0])
mc.delete(groupUp)
mc.delete(groupAim)
startLoc = rigging.doParentReturnName(startLoc,transformGroup)
rigging.zeroTransformMeObject(startLoc)
returnLoc.append(startLoc)
returnLoc.append(transformGroup)
zeroGroup = rigging.groupMeObject(transformGroup)
attributes.storeInfo(zeroGroup,'move',transformGroup)
returnLoc.append(zeroGroup)
return returnLoc
elif modeType == 'radialDown':
sizeObjectLength = distance.returnDistanceBetweenObjects(workingObject,aimingObject)
returnLoc = []
workingObjectShapes = mc.listRelatives(workingObject, shapes = True)
aimingObjectShapes = mc.listRelatives(aimingObject, shapes = True)
"""initial loc creation and orientation"""
startLoc = locators.locMeCvFromCvIndex(workingObjectShapes[0],cvIndex)
startLocAim = locators.locMeCvFromCvIndex(workingObjectShapes[0],cvIndex)
startLoc = mc.rename(startLoc, (self.ModuleNull.nameBase+'_radialDown_startLoc'))
StartLoc = ObjectFactory(startLoc)
""" move the up loc up """
mc.xform(startLocAim,t=[0,-sizeObjectLength,0],r=True, ws=True)
""" aim it """
aimConstraintBuffer = mc.aimConstraint(startLocAim,startLoc,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,0,1], worldUpType = 'vector' )
mc.delete(aimConstraintBuffer[0])
""" setup the transform group"""
transformGroup = rigging.groupMeObject(startLoc,False)
transformGroup = mc.rename(transformGroup,('%s%s' %(startLoc,'_moveGroup')))
groupUp = startLocAim
groupAim = locators.locMeCvFromCvIndex(aimingObjectShapes[0],cvIndex)
"""aim it"""
aimConstraintBuffer = mc.aimConstraint(groupAim,transformGroup,maintainOffset = False, weight = 1, aimVector = [0,0,1], upVector = [0,-1,0], worldUpObject = groupUp, worldUpType = 'object')
mc.delete(aimConstraintBuffer[0])
mc.delete(groupUp)
mc.delete(groupAim)
startLoc = rigging.doParentReturnName(startLoc,transformGroup)
rigging.zeroTransformMeObject(startLoc)
returnLoc.append(startLoc)
returnLoc.append(transformGroup)
zeroGroup = rigging.groupMeObject(transformGroup)
attributes.storeInfo(zeroGroup,'move',transformGroup)
returnLoc.append(zeroGroup)
return returnLoc
elif modeType == 'footBase':
returnLoc = []
startLoc = locators.locMeObject(workingObject)
startLoc = mc.rename(startLoc,(self.ModuleNull.nameBase+'_footcgmase_startLoc'))
StartLoc = ObjectFactory(startLoc)
masterGroup = rigging.groupMeObject(startLoc)
mc.setAttr((startLoc+'.rx'),-90)
returnLoc.append(startLoc)
zeroGroup = rigging.zeroTransformMeObject(startLoc)
currentPos = mc.xform(zeroGroup,q=True, t=True,ws=True)
mc.xform(zeroGroup,t=[currentPos[0],0,currentPos[2]], ws = True)
attributes.storeInfo(zeroGroup,'locator',startLoc)
returnLoc.append(zeroGroup)
returnLoc.append(masterGroup)
return returnLoc
elif modeType == 'parentDuplicate':
returnLoc = []
startLoc = locators.locMeObject(workingObject)
startLoc = mc.rename(startLoc,(self.ModuleNull.nameBase+'_parentDup_startLoc'))
StartLoc = ObjectFactory(startLoc)
masterGroup = rigging.groupMeObject(startLoc)
returnLoc.append(startLoc)
returnLoc.append(masterGroup)
return returnLoc
else:
return False
def verifyModule(self,forceNew = False):
"""
Verifies the integrity of the base module class null. Repairing and restoring broken connections or deleted items.
"""
for k in defaultSettings.keys():
try:
self.__dict__[k]
except:
self.__dict__[k] = defaultSettings[k]
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Nulls creation
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#need a check to see if it exists from specfic name call
if not self.ModuleNull or forceNew:
#See if one exists from the name dict
buffer = NameFactory.returnCombinedNameFromDict(self.generateNameDict())
if mc.objExists(buffer):
if forceNew:
cnt = NameFactory.returnIterateNumber(buffer)
self.ModuleNull = ObjectFactory(mc.group(empty=True))
self.ModuleNull.store('cgmIterator',cnt)
else:
self.ModuleNull = ObjectFactory(buffer)
#if we still don't have one, make it
if not self.ModuleNull:
self.ModuleNull = ObjectFactory(mc.group(empty=True))
#Initialize the module parent attr
self.msgModuleParent = AttrFactory(self.ModuleNull,'moduleParent','message',self.moduleParent)
#Naming stuff
self.ModuleNull.store('cgmName',self.nameBase,True)
self.ModuleNull.store('cgmType','module')
self.afModuleType = AttrFactory(self.ModuleNull,'moduleType',initialValue='None')
#Store any naming tags from the init call
for k in self.callTags.keys():
if self.callTags.get(k):
self.ModuleNull.store(k,self.callTags.get(k),True)
elif k in self.parentTagDict.keys():
self.ModuleNull.store(k,'%s.%s'%(self.msgModuleParent.value,k))
self.ModuleNull.doName(True)
mc.xform (self.ModuleNull.nameShort, os=True, piv= (0,0,0))
for flag in moduleStates:
self.__dict__["af%sState"%flag.capitalize()] = AttrFactory(self.ModuleNull,'%sState'%flag,'bool',initialValue=0,lock=True)
attributes.doSetLockHideKeyableAttr(self.ModuleNull.nameShort,channels=['tx','ty','tz','rx','ry','rz','sx','sy','sz'])
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Main Nulls
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
self.msgRigNull = AttrFactory(self.ModuleNull,'rigNull','message')
self.msgTemplateNull = AttrFactory(self.ModuleNull,'templateNull','message')
self.msgInfoNull = AttrFactory(self.ModuleNull,'info','message')
nullAttributes = [self.msgRigNull, self.msgTemplateNull, self.msgInfoNull]
nullInstances = ['RigNull', 'TemplateNull', 'InfoNull']
for i,null in enumerate(nullAttributes):
created = False
if not null.get():
#If there's nothing connected to our message, we're gonna make our null
guiFactory.report("'%s' not found. Creating"%null.attr)
self.__dict__[ nullInstances[i] ] = ObjectFactory(mc.group(empty=True))
created = True
else:
self.__dict__[ nullInstances[i] ] = ObjectFactory(null.value)
if null.attr == 'info':
#Special case stuff for the master info null
self.__dict__[ nullInstances[i] ].store('cgmName','master',True)
self.__dict__[ nullInstances[i] ].store('cgmType','infoNull')
else:
self.__dict__[ nullInstances[i] ].store('cgmType',null.attr)
mc.xform (self.__dict__[ nullInstances[i] ].nameShort, os=True, piv= (0,0,0))
self.__dict__[ nullInstances[i] ].doParent(self.ModuleNull.nameShort)
if created and self.__dict__[ nullInstances[i] ].nameLong != null.value:
null.doStore(self.__dict__[ nullInstances[i] ].nameLong)
attributes.doSetLockHideKeyableAttr(self.__dict__[ nullInstances[i] ].nameShort)
self.__dict__[ nullInstances[i] ].doName(True)
null.updateData()
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Info Nulls
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
for k in InfoNullsNames:
self.infoNulls[k] = AttrFactory(self.InfoNull,k,'message')
if not self.infoNulls[k].value:
guiFactory.report("'%s' not found. Creating"%k)
createBuffer = modules.createInfoNull(k)
self.infoNulls[k].doStore(createBuffer)
if self.infoNulls[k].value:
attributes.doSetLockHideKeyableAttr(self.infoNulls[k].value)
if rigging.doParentReturnName( self.infoNulls[k].value,self.msgInfoNull.value):
buffer = NameFactory.doNameObject(self.infoNulls[k].value)
if buffer != self.infoNulls[k].value:
self.infoNulls[k].doStore(buffer)
else:
self.infoNulls[k].updateData()
else:
guiFactory.warning("'%s' has failed to initialize"%k)
if self.infoNulls['setupOptions']:
self.SetupOptionsNull = ObjectFactory( self.infoNulls['setupOptions'].get() )
self.optionHandles = AttrFactory(self.SetupOptionsNull,'handles','int',initialValue=self.handles)
if self.infoNulls['settings']:
self.optionAimAxis = AttrFactory(self.infoNulls['settings'].get(),'axisAim','enum',enum = 'x+:y+:z+:x-:y-:z-',initialValue=2)
self.optionUpAxis = AttrFactory(self.infoNulls['settings'].get(),'axisUp','enum',enum = 'x+:y+:z+:x-:y-:z-',initialValue=1)
self.optionOutAxis = AttrFactory(self.infoNulls['settings'].get(),'axisOut','enum',enum = 'x+:y+:z+:x-:y-:z-',initialValue=0)
return True
def parentObjectToNameObject(object):
object = NameFactory(object)
if mc.objExists(object.cgm['cgmName']):
obj = rigging.doParentReturnName(object.nameLong,object.cgm['cgmName'])
def attachAimedObjectToSurface (obj, surface, aimObject, parent = True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Script to rename a joint chain list
ARGUMENTS:
jointList(list) - list of joints in order
startJointName(string) - what you want the root named
interiorJointRootName(string) - what you want the iterative name to be
RETURNS:
newJoints(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
""" Make a transform group """
surfaceLoc = locators.locMeClosestUVOnSurface(obj,surface)
surfaceFollowGroup = rigging.groupMeObject(surfaceLoc,False)
transformGroup = rigging.groupMeObject(obj,False)
surfaceFollowGroup = mc.rename(surfaceFollowGroup,(obj+'_surfaceFollowGroup'))
attributes.storeInfo(surfaceFollowGroup,'object',obj)
transformGroup = mc.rename(transformGroup,(obj+'_surfaceFollowTransformGroup'))
attributes.storeInfo(transformGroup,'object',obj)
controlSurface = mc.listRelatives(surface,shapes=True)
""" make the node """
closestPointNode = mc.createNode ('closestPointOnSurface',name= (obj+'_closestPointInfoNode'))
""" to account for target objects in heirarchies """
attributes.doConnectAttr((surfaceLoc+'.translate'),(closestPointNode+'.inPosition'))
attributes.doConnectAttr((controlSurface[0]+'.worldSpace'),(closestPointNode+'.inputSurface'))
pointOnSurfaceNode = mc.createNode ('pointOnSurfaceInfo',name= (obj+'_posInfoNode'))
""" Connect the info node to the surface """
attributes.doConnectAttr ((controlSurface[0]+'.worldSpace'),(pointOnSurfaceNode+'.inputSurface'))
""" Contect the pos group to the info node"""
attributes.doConnectAttr ((pointOnSurfaceNode+'.position'),(surfaceFollowGroup+'.translate'))
attributes.doConnectAttr ((closestPointNode+'.parameterU'),(pointOnSurfaceNode+'.parameterU'))
attributes.doConnectAttr ((closestPointNode+'.parameterV'),(pointOnSurfaceNode+'.parameterV'))
""" if we wanna aim """
if aimObject != False:
""" make some locs """
upLoc = locators.locMeObject(surface)
aimLoc = locators.locMeObject(aimObject)
attributes.storeInfo(upLoc,'cgmName',obj)
attributes.storeInfo(upLoc,'cgmTypeModifier','up')
upLoc = NameFactoryOld.doNameObject(upLoc)
attributes.storeInfo(aimLoc,'cgmName',aimObject)
attributes.storeInfo(aimLoc,'cgmTypeModifier','aim')
aimLoc = NameFactoryOld.doNameObject(aimLoc)
attributes.storeInfo(surfaceFollowGroup,'locatorUp',upLoc)
attributes.storeInfo(surfaceFollowGroup,'aimLoc',aimLoc)
#mc.parent(upLoc,aimObject)
boundingBoxSize = distance.returnBoundingBoxSize(surface)
distance = max(boundingBoxSize)*2
mc.xform(upLoc,t = [0,distance,0],ws=True,r=True)
attributes.doConnectAttr((aimLoc+'.translate'),(closestPointNode+'.inPosition'))
""" constrain the aim loc to the aim object """
pointConstraintBuffer = mc.pointConstraint(aimObject,aimLoc,maintainOffset = True, weight = 1)
""" aim it """
aimConstraintBuffer = mc.aimConstraint(aimLoc,surfaceFollowGroup,maintainOffset = True, weight = 1, aimVector = [0,0,1], upVector = [0,1,0], worldUpObject = upLoc, worldUpType = 'object' )
""" aim the controller back at the obj"""
aimConstraintBuffer = mc.aimConstraint(obj,aimLoc,maintainOffset = True, weight = 1, aimVector = [0,0,-1], upVector = [0,1,0], worldUpObject = upLoc, worldUpType = 'object' )
mc.parent(upLoc,aimObject)
else:
mc.delete(closestPointNode)
transformGroup = rigging.doParentReturnName(transformGroup,surfaceFollowGroup)
"""finally parent it"""
if parent == True:
mc.parent(obj,transformGroup)
if parent == 'constrain':
mc.parentConstraint(transformGroup,obj,maintainOffset = True)
mc.delete(surfaceLoc)
return [transformGroup,surfaceFollowGroup]
def parentObjectToNameObject(object):
object = NameFactory(object)
if mc.objExists(object.cgm['cgmName']):
obj = rigging.doParentReturnName(object.nameLong,object.cgm['cgmName'])
def createMasterNull(characterName='nothingNothing'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Creates a masterNull for a character/asset
ARGUMENTS:
characterName(string)
RETURNS:
masterNull(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
if characterName == 'nothingNothing':
randomOptions = ['David', 'Josh', 'NameMe', 'Homer', 'Georgie']
characterName = random.choice(randomOptions)
#Create main null
masterNullBuffer = mc.group(empty=True)
attributes.storeInfo(masterNullBuffer, 'cgmName', characterName)
attributes.storeInfo(masterNullBuffer, 'cgmType', 'ignore')
attributes.storeInfo(masterNullBuffer, 'cgmModuleType', 'master')
masterNull = NameFactory.doNameObject(masterNullBuffer)
#Create modules container null
modulesGroupBuffer = mc.group(empty=True)
attributes.storeInfo(modulesGroupBuffer, 'cgmName', 'modules')
attributes.storeInfo(modulesGroupBuffer, 'cgmType', 'group')
modulesGroup = NameFactory.doNameObject(modulesGroupBuffer)
modulesGroup = rigging.doParentReturnName(modulesGroup, masterNull)
attributes.storeObjectToMessage(modulesGroup, masterNull, 'modulesGroup')
#Create modules container null
meshGroupBuffer = mc.group(empty=True)
attributes.storeInfo(meshGroupBuffer, 'cgmName', 'geo')
attributes.storeInfo(modulesGroupBuffer, 'cgmType', 'group')
meshGroup = NameFactory.doNameObject(modulesGroupBuffer)
meshGroup = rigging.doParentReturnName(meshGroup, masterNull)
attributes.storeObjectToMessage(meshGroup, masterNull, 'geoGroup')
#Create master info null
masterInfoNull = createInfoNull('master')
attributes.storeObjectToMessage(masterInfoNull, masterNull, 'info')
masterInfoNull = rigging.doParentReturnName(masterInfoNull, masterNull)
#Create modules info null
modulesInfoNull = createInfoNull('modules')
attributes.storeObjectToMessage(modulesInfoNull, masterInfoNull, 'modules')
modulesInfoNull = rigging.doParentReturnName(modulesInfoNull,
masterInfoNull)
#Create mesh info null
meshInfoNull = createInfoNull('geo')
attributes.storeObjectToMessage(meshInfoNull, masterInfoNull, 'geo')
modulesInfoNull = rigging.doParentReturnName(meshInfoNull, masterInfoNull)
#Create global settings info null
settingsInfoNull = createInfoNull('settings')
attributes.storeObjectToMessage(settingsInfoNull, masterInfoNull,
'settings')
settingsInfoNull = rigging.doParentReturnName(settingsInfoNull,
masterInfoNull)
defaultFont = returnSettingsData('defaultTextFont')
attributes.storeInfo(settingsInfoNull, 'font', defaultFont)
return masterNull
def createMasterNull(characterName='nothingNothing'):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Creates a masterNull for a character/asset
ARGUMENTS:
characterName(string)
RETURNS:
masterNull(string)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
if characterName == 'nothingNothing':
randomOptions = ['David','Josh','NameMe','Homer','Georgie']
characterName = random.choice(randomOptions)
#Create main null
masterNullBuffer = mc.group (empty=True)
attributes.storeInfo(masterNullBuffer,'cgmName',characterName)
attributes.storeInfo(masterNullBuffer,'cgmType','ignore')
attributes.storeInfo(masterNullBuffer,'cgmModuleType','master')
masterNull = NameFactory.doNameObject(masterNullBuffer)
#Create modules container null
modulesGroupBuffer = mc.group (empty=True)
attributes.storeInfo(modulesGroupBuffer,'cgmName','modules')
attributes.storeInfo(modulesGroupBuffer,'cgmType','group')
modulesGroup = NameFactory.doNameObject(modulesGroupBuffer)
modulesGroup = rigging.doParentReturnName(modulesGroup,masterNull)
attributes.storeObjectToMessage (modulesGroup, masterNull, 'modulesGroup')
#Create modules container null
meshGroupBuffer = mc.group (empty=True)
attributes.storeInfo(meshGroupBuffer,'cgmName','geo')
attributes.storeInfo(modulesGroupBuffer,'cgmType','group')
meshGroup = NameFactory.doNameObject(modulesGroupBuffer)
meshGroup = rigging.doParentReturnName(meshGroup,masterNull)
attributes.storeObjectToMessage (meshGroup, masterNull, 'geoGroup')
#Create master info null
masterInfoNull = createInfoNull('master')
attributes.storeObjectToMessage (masterInfoNull, masterNull, 'info')
masterInfoNull = rigging.doParentReturnName(masterInfoNull,masterNull)
#Create modules info null
modulesInfoNull = createInfoNull('modules')
attributes.storeObjectToMessage (modulesInfoNull, masterInfoNull, 'modules')
modulesInfoNull = rigging.doParentReturnName(modulesInfoNull,masterInfoNull)
#Create mesh info null
meshInfoNull = createInfoNull('geo')
attributes.storeObjectToMessage (meshInfoNull, masterInfoNull, 'geo')
modulesInfoNull = rigging.doParentReturnName(meshInfoNull,masterInfoNull)
#Create global settings info null
settingsInfoNull = createInfoNull('settings')
attributes.storeObjectToMessage (settingsInfoNull, masterInfoNull, 'settings')
settingsInfoNull = rigging.doParentReturnName(settingsInfoNull,masterInfoNull)
defaultFont = returnSettingsData('defaultTextFont')
attributes.storeInfo(settingsInfoNull,'font',defaultFont)
return masterNull
def bakeBlendShapeNodeToTargetObject(targetObject,sourceObject, blendShapeNode, baseNameToUse = False, stripPrefix = False,ignoreInbetweens = False, ignoreTargets = False, transferConnections = True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for baking a series of blendshapes from one object to another
ARGUMENTS:
targetObject(string)
sourceObject(string)
blendShapeNode(string) the node to bake from
baseNameToUse(bool/string) - if it's False, it uses the target Object name, else, it uses what is supplied
stripPrefix(bool)
ignoreInbetweens(bool)
ignoreTargets(list) - list of targets to ignore
transferConnections(bool) - if True, builds a new blendshape node and transfers the connections from our base objects
RETURNS:
Success(bool)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Prep
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" declare variables """
returnList = []
blendShapeNamesBaked = []
blendShapeConnections = []
currentConnections = []
bakedGeo = []
""" size """
sizeBuffer = distance.returnBoundingBoxSize(targetObject)
sizeX = sizeBuffer[0]
sizeY = sizeBuffer[1]
""" base name """
if baseNameToUse == False:
baseName = ''
else:
baseName = baseNameToUse + '_'
""" wrap deform object """
wrapBuffer = wrapDeformObject(targetObject,sourceObject,True)
targetObjectBaked = wrapBuffer[1]
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Meat of it
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
blendShapeNodeChannels = returnBlendShapeAttributes(blendShapeNode)
blendShapeShortNames = []
""" first loop stores and sets everything to 0 """
for shape in blendShapeNodeChannels:
keepGoing = True
if ignoreTargets != False:
if shape in ignoreTargets:
keepGoing = False
else:
keepGoing = True
blendShapeBuffer = (blendShapeNode + '.' + shape)
""" get the connection """
blendShapeConnections.append(attributes.returnDriverAttribute(blendShapeBuffer))
if keepGoing == True:
print ('breaking....' + blendShapeBuffer)
"""break it """
attributes.doBreakConnection(blendShapeBuffer)
attributes.doSetAttr(blendShapeNode,shape,0)
# Bake it
bakedGeo = bakeBlendShapes(sourceObject, targetObjectBaked, blendShapeNode, baseNameToUse, stripPrefix, ignoreInbetweens, ignoreTargets)
""" restore connections """
for shape in blendShapeNodeChannels:
keepGoing = True
if ignoreTargets != False:
if shape in ignoreTargets:
keepGoing = False
else:
keepGoing = True
currentIndex = blendShapeNodeChannels.index(shape)
blendShapeBuffer = (blendShapeNode+'.'+shape)
""" Restore the connection """
if keepGoing == True:
print ('connecting....' + blendShapeBuffer)
print blendShapeConnections[currentIndex]
if blendShapeConnections[currentIndex] != False:
attributes.doConnectAttr(blendShapeConnections[currentIndex],blendShapeBuffer)
# Need to build a new blendshape node?
if transferConnections == True:
# Build it
newBlendShapeNode = buildBlendShapeNode(targetObject, bakedGeo, baseNameToUse)
newBlendShapeChannels = returnBlendShapeAttributes(newBlendShapeNode)
for shape in newBlendShapeChannels:
blendShapeBuffer = (newBlendShapeNode+'.'+shape)
currentIndex = newBlendShapeChannels.index(shape)
if blendShapeConnections[currentIndex] != False:
attributes.doConnectAttr(blendShapeConnections[currentIndex],blendShapeBuffer)
"""delete the wrap"""
mc.delete(wrapBuffer[0])
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Finish out
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" group for geo """
meshGroup = mc.group( em=True)
if baseNameToUse != False:
attributes.storeInfo(meshGroup,'cgmName', baseNameToUse)
attributes.storeInfo(meshGroup,'cgmTypeModifier', 'blendShapeGeo')
meshGroup = NameFactory.doNameObject(meshGroup)
for geo in bakedGeo:
rigging.doParentReturnName(geo,meshGroup)
returnList.append(meshGroup)
returnList.append(bakedGeo)
mc.delete(targetObjectBaked)
return returnList
def bakeCombinedBlendShapeNodeToTargetObject(targetObject,sourceObject, blendShapeNode, baseName = False, directions=['left','right']):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for baking a series of blendshapes from one object to another when you have a left/right variant
ARGUMENTS:
targetObject(string)
sourceObject(string)
blendShapeNode(string) the node to bake from
baseName(bool/string) - if it's False, it uses the target Object name, else, it uses what is supplied
directions[list] = (['left','right'])
RETURNS:
Success(bool)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Prep
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" declare variables """
returnList = []
blendShapeNamesBaked = []
blendShapeConnections = []
currentConnections = []
bakedGeo = []
""" size """
sizeBuffer = distance.returnBoundingBoxSize(targetObject)
sizeX = sizeBuffer[0]
sizeY = sizeBuffer[1]
""" base name """
if baseName == False:
baseName = ''
else:
baseName = baseName + '_'
"""reference check """
refPrefix = search.returnReferencePrefix(sourceObject)
if refPrefix != False:
referencePrefix = (search.returnReferencePrefix(sourceObject) + ':')
else:
referencePrefix = ''
""" wrap deform object """
wrapBuffer = wrapDeformObject(targetObject,sourceObject,True)
targetObjectBaked = wrapBuffer[1]
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Meat of it
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#setAttr ($wrapDeformer[0] + ".autoWeightThreshold") 1;
""" cause maya is stupid and doesn't have a python equivalent"""
mc.select(targetObjectBaked,r=True)
mc.select(sourceObject,tgl=True)
mel.eval('AddWrapInfluence')
mc.select(cl=True)
"""
may need to add this in later
//reorders deformation order for proper baking of skinned mesh
//reorderDeformers "tweak1" "face_skinCluster" $deformerGeo;
"""
blendShapeNodeChannels = search.returnBlendShapeAttributes(blendShapeNode)
blendShapeShortNames = []
""" first loop stores and sets everything to 0 """
for shape in blendShapeNodeChannels:
blendShapeBuffer = (blendShapeNode+'.'+shape)
blendShapeConnections.append(attributes.returnDriverAttribute(blendShapeBuffer))
"""break it """
attributes.doBreakConnection(blendShapeBuffer)
attributes.doSetAttr(blendShapeNode,shape,0)
""" Find pairs """
blendshapePairs = lists.returnMatchedStrippedEndList(blendShapeNodeChannels,directions)
""" first loop stores and sets everything to 0 """
for pair in blendshapePairs:
blendShapeBuffer = (blendShapeNode+'.'+pair[0])
splitBuffer = pair[0].split('_')
nameBuffer = splitBuffer[:-1]
pairBaseName = '_'.join(nameBuffer)
if '_' in list(pairBaseName):
newSplitBuffer = pair[0].split('_')
newNameBuffer = newSplitBuffer[1:]
blendShapeShortNames.append('_'.join(newNameBuffer))
else:
blendShapeShortNames.append(pairBaseName)
t=1
pair = 0
for i in range (len(blendshapePairs)):
row = i//5
if t>5:
t=1
""" start extracting """
blendShapeNodeChannelsBuffer = blendshapePairs[pair]
shape1 = blendShapeNodeChannelsBuffer[0]
shape2 = blendShapeNodeChannelsBuffer[1]
attributes.doSetAttr(blendShapeNode,shape1,1)
attributes.doSetAttr(blendShapeNode,shape2,1)
dupBuffer = mc.duplicate(targetObjectBaked)
splitBuffer = blendShapeShortNames[pair].split('_')
nameBuffer = splitBuffer[:-1]
shortName = '_'.join(nameBuffer)
dupBuffer = mc.rename (dupBuffer,(baseName+shortName))
mc.xform(dupBuffer,r=True,t=[((sizeX*(t+1.2))*1.5),(sizeY*row*-1.5),0])
bakedGeo.append(dupBuffer)
attributes.doSetAttr(blendShapeNode,shape1,0)
attributes.doSetAttr(blendShapeNode,shape2,0)
pair +=1
t+=1
""" restore connections """
for shape in blendShapeNodeChannels:
currentIndex = blendShapeNodeChannels.index(shape)
blendShapeBuffer = (blendShapeNode+'.'+shape)
""" Restore the connection """
if blendShapeConnections[currentIndex] != False:
attributes.doConnectAttr(blendShapeConnections[currentIndex],blendShapeBuffer)
"""delete the wrap"""
mc.delete(wrapBuffer[0])
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Finish out
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" group for geo """
meshGroup = mc.group( em=True)
attributes.storeInfo(meshGroup,'cgmName', baseName)
attributes.storeInfo(meshGroup,'cgmTypeModifier', 'blendShapeGeo')
meshGroup = NameFactory.doNameObject(meshGroup)
for geo in bakedGeo:
rigging.doParentReturnName(geo,meshGroup)
returnList.append(meshGroup)
returnList.append(bakedGeo)
mc.delete(targetObjectBaked)
return returnList
def attachAimedObjectToSurface(obj, surface, aimObject, parent=True):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Script to rename a joint chain list
ARGUMENTS:
jointList(list) - list of joints in order
startJointName(string) - what you want the root named
interiorJointRootName(string) - what you want the iterative name to be
RETURNS:
newJoints(list)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
""" Make a transform group """
surfaceLoc = locators.locMeClosestUVOnSurface(obj, surface)
surfaceFollowGroup = rigging.groupMeObject(surfaceLoc, False)
transformGroup = rigging.groupMeObject(obj, False)
surfaceFollowGroup = mc.rename(surfaceFollowGroup,
(obj + '_surfaceFollowGroup'))
attributes.storeInfo(surfaceFollowGroup, 'object', obj)
transformGroup = mc.rename(transformGroup,
(obj + '_surfaceFollowTransformGroup'))
attributes.storeInfo(transformGroup, 'object', obj)
controlSurface = mc.listRelatives(surface, shapes=True)
""" make the node """
closestPointNode = mc.createNode('closestPointOnSurface',
name=(obj + '_closestPointInfoNode'))
""" to account for target objects in heirarchies """
attributes.doConnectAttr((surfaceLoc + '.translate'),
(closestPointNode + '.inPosition'))
attributes.doConnectAttr((controlSurface[0] + '.worldSpace'),
(closestPointNode + '.inputSurface'))
pointOnSurfaceNode = mc.createNode('pointOnSurfaceInfo',
name=(obj + '_posInfoNode'))
""" Connect the info node to the surface """
attributes.doConnectAttr((controlSurface[0] + '.worldSpace'),
(pointOnSurfaceNode + '.inputSurface'))
""" Contect the pos group to the info node"""
attributes.doConnectAttr((pointOnSurfaceNode + '.position'),
(surfaceFollowGroup + '.translate'))
attributes.doConnectAttr((closestPointNode + '.parameterU'),
(pointOnSurfaceNode + '.parameterU'))
attributes.doConnectAttr((closestPointNode + '.parameterV'),
(pointOnSurfaceNode + '.parameterV'))
""" if we wanna aim """
if aimObject != False:
""" make some locs """
upLoc = locators.locMeObject(surface)
aimLoc = locators.locMeObject(aimObject)
attributes.storeInfo(upLoc, 'cgmName', obj)
attributes.storeInfo(upLoc, 'cgmTypeModifier', 'up')
upLoc = NameFactory.doNameObject(upLoc)
attributes.storeInfo(aimLoc, 'cgmName', aimObject)
attributes.storeInfo(aimLoc, 'cgmTypeModifier', 'aim')
aimLoc = NameFactory.doNameObject(aimLoc)
attributes.storeInfo(surfaceFollowGroup, 'locatorUp', upLoc)
attributes.storeInfo(surfaceFollowGroup, 'aimLoc', aimLoc)
#mc.parent(upLoc,aimObject)
boundingBoxSize = distance.returnBoundingBoxSize(surface)
distance = max(boundingBoxSize) * 2
mc.xform(upLoc, t=[0, distance, 0], ws=True, r=True)
attributes.doConnectAttr((aimLoc + '.translate'),
(closestPointNode + '.inPosition'))
""" constrain the aim loc to the aim object """
pointConstraintBuffer = mc.pointConstraint(aimObject,
aimLoc,
maintainOffset=True,
weight=1)
""" aim it """
aimConstraintBuffer = mc.aimConstraint(aimLoc,
surfaceFollowGroup,
maintainOffset=True,
weight=1,
aimVector=[0, 0, 1],
upVector=[0, 1, 0],
worldUpObject=upLoc,
worldUpType='object')
""" aim the controller back at the obj"""
aimConstraintBuffer = mc.aimConstraint(obj,
aimLoc,
maintainOffset=True,
weight=1,
aimVector=[0, 0, -1],
upVector=[0, 1, 0],
worldUpObject=upLoc,
worldUpType='object')
mc.parent(upLoc, aimObject)
else:
mc.delete(closestPointNode)
transformGroup = rigging.doParentReturnName(transformGroup,
surfaceFollowGroup)
"""finally parent it"""
if parent == True:
mc.parent(obj, transformGroup)
if parent == 'constrain':
mc.parentConstraint(transformGroup, obj, maintainOffset=True)
mc.delete(surfaceLoc)
return [transformGroup, surfaceFollowGroup]
def bakeCombinedBlendShapeNode(sourceObject, blendShapeNode, baseNameToUse = False, directions=['left','right']):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Function for baking a series of blendshapes out from one object that have a split type
ARGUMENTS:
sourceObject(string)
sourceObject(string)
blendShapeNode(string) the node to bake from
baseName(bool/string) - if it's False, it uses the target Object name, else, it uses what is supplied
directions[list] = (['left','right'])
RETURNS:
Success(bool)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Prep
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" declare variables """
returnList = []
blendShapeNamesBaked = []
blendShapeConnections = []
currentConnections = []
bakedGeo = []
""" size """
sizeBuffer = distance.returnBoundingBoxSize(sourceObject)
sizeX = sizeBuffer[0]
sizeY = sizeBuffer[1]
""" base name """
if baseNameToUse == False:
baseName = ''
else:
baseName = baseNameToUse + '_'
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Meat of it
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
blendShapeNodeChannels = search.returnBlendShapeAttributes(blendShapeNode)
blendShapeShortNames = []
""" first loop stores and sets everything to 0 """
for shape in blendShapeNodeChannels:
blendShapeBuffer = (blendShapeNode+'.'+shape)
blendShapeConnections.append(attributes.returnDriverAttribute(blendShapeBuffer))
"""break it """
attributes.doBreakConnection(blendShapeBuffer)
attributes.doSetAttr(blendShapeBuffer,0)
""" Find pairs """
blendshapePairs = lists.returnMatchedStrippedEndList(blendShapeNodeChannels,directions)
""" first loop stores and sets everything to 0 """
for pair in blendshapePairs:
blendShapeBuffer = (blendShapeNode+'.'+pair[0])
splitBuffer = pair[0].split('_')
nameBuffer = splitBuffer[:-1]
pairBaseName = '_'.join(nameBuffer)
if '_' in list(pairBaseName):
newSplitBuffer = pair[0].split('_')
newNameBuffer = newSplitBuffer[1:]
blendShapeShortNames.append('_'.join(newNameBuffer))
else:
blendShapeShortNames.append(pairBaseName)
t=1
pair = 0
for i in range (len(blendshapePairs)):
row = i//5
if t>5:
t=1
""" start extracting """
blendShapeNodeChannelsBuffer = blendshapePairs[pair]
shape1 = blendShapeNodeChannelsBuffer[0]
shape2 = blendShapeNodeChannelsBuffer[1]
blendShape1Buffer = (blendShapeNode+'.'+shape1)
blendShape2Buffer = (blendShapeNode+'.'+shape2)
attributes.doSetAttr(blendShape1Buffer,1)
attributes.doSetAttr(blendShape2Buffer,1)
dupBuffer = mc.duplicate(sourceObject)
splitBuffer = blendShapeShortNames[pair].split('_')
if len(splitBuffer)>1:
nameBuffer = splitBuffer[:-1]
else:
nameBuffer = splitBuffer
shortName = '_'.join(nameBuffer)
dupBuffer = mc.rename (dupBuffer,(baseName+shortName))
""" Unlock it """
attributes.doSetLockHideKeyableAttr(dupBuffer,False,True,True)
mc.xform(dupBuffer,r=True,t=[((sizeX*(t+1.2))*1.5),(sizeY*row*-1.5),0])
bakedGeo.append(dupBuffer)
attributes.doSetAttr(blendShape1Buffer,0)
attributes.doSetAttr(blendShape2Buffer,0)
pair +=1
t+=1
""" restore connections """
for shape in blendShapeNodeChannels:
currentIndex = blendShapeNodeChannels.index(shape)
blendShapeBuffer = (blendShapeNode+'.'+shape)
""" Restore the connection """
if blendShapeConnections[currentIndex] != False:
attributes.doConnectAttr(blendShapeConnections[currentIndex],blendShapeBuffer)
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
# Finish out
#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
""" group for geo """
meshGroup = mc.group( em=True)
attributes.storeInfo(meshGroup,'cgmName', baseNameToUse)
attributes.storeInfo(meshGroup,'cgmTypeModifier', 'blendShapeGeo')
meshGroup = NameFactory.doNameObject(meshGroup)
for geo in bakedGeo:
rigging.doParentReturnName(geo,meshGroup)
returnList.append(meshGroup)
returnList.append(bakedGeo)
return returnList
def returnAbsoluteSizeCurve(curve):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Pass an curve into it and it returns absolute distance scale
ARGUMENTS:
curve(string) - curve
RETURNS:
distances(list) - [xLength,yLength,zLength]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
def duplicateShape(shape):
parentObj = mc.listRelatives(shape, p=True, fullPath=True)
shapes = mc.listRelatives(parentObj, shapes=True, fullPath=True)
matchObjName = mc.ls(shape, long=True)
matchIndex = shapes.index(matchObjName[0])
dupBuffer = mc.duplicate(parentObj)
children = mc.listRelatives(dupBuffer[0], children = True, fullPath =True)
if len(children) > 0:
for c in children:
if search.returnObjectType(c) != 'shape':
mc.delete(c)
dupShapes = mc.listRelatives(dupBuffer[0], shapes=True, fullPath=True)
for shape in dupShapes:
if dupShapes.index(shape) != matchIndex:
mc.delete(shape)
return dupBuffer[0]
boundingBoxSize = returnBoundingBoxSize(curve)
if mayaVersion <=2010:
return boundingBoxSize
else:
distanceToMove = max(boundingBoxSize)
positions = []
isShape = False
if search.returnObjectType(curve) == 'shape':
dupCurve = duplicateShape(curve)
curve = dupCurve
isShape = True
loc = rigging.locMeObjectStandAlone(curve)
locGroup = rigging.groupMeObject(loc,False)
loc = rigging.doParentReturnName(loc,locGroup)
directions = ['x','y','z']
for direction in directions:
positionsBuffer = []
mc.setAttr((loc+'.t'+direction),distanceToMove)
positionsBuffer.append(returnClosestUPosition(loc,curve))
mc.setAttr((loc+'.t'+direction),-distanceToMove)
positionsBuffer.append(returnClosestUPosition(loc,curve))
mc.setAttr((loc+'.t'+direction),0)
positions.append(positionsBuffer)
distances = []
for set in positions:
distances.append(returnDistanceBetweenPoints(set[0],set[1]))
if isShape == True:
mc.delete(dupCurve)
mc.delete(locGroup)
return distances
def addOrientationHelpers(self):
"""
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
DESCRIPTION:
Adds orientation helpers to a template chain
ARGUMENTS:
objects(list)
root(string) - root control of the limb chain
moduleType(string)
RETURNS:
returnList(list) = [rootHelper(string),helperObjects(list),helperObjectGroups(list)]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"""
moduleColors = modules.returnModuleColors(self.ModuleNull.nameLong)
helperObjects = []
helperObjectGroups = []
returnBuffer = []
root = self.msgTemplateRoot.getMessage()
visAttr = "%s.visOrientHelpers" % self.infoNulls['visibilityOptions'].get()
objects = self.templatePosObjectsBuffer.bufferList
#>>> Direction and size Stuff
""" Directional data derived from joints """
generalDirection = logic.returnHorizontalOrVertical(objects)
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]
#Get Size
size = (distance.returnBoundingBoxSizeToAverage(objects[0]) * 2)
#>>> Master Orient helper
createBuffer = curves.createControlCurve('circleArrow1', (size * 2),
'z+') # make the curve
curves.setCurveColorByName(createBuffer, moduleColors[0])
attributes.storeInfo(createBuffer, 'cgmType',
'templateOrientRoot') #copy the name attr
mainOrientHelperObj = NameFactory.doNameObject(createBuffer)
attributes.storeObjectToMessage(
mainOrientHelperObj, self.msgTemplateRoot.get(),
'orientHelper') #store the object to it's respective object
returnBuffer.append(mainOrientHelperObj)
# Snapping
position.movePointSnap(mainOrientHelperObj, root)
constBuffer = mc.aimConstraint(objects[1],
mainOrientHelperObj,
maintainOffset=False,
weight=1,
aimVector=[1, 0, 0],
upVector=[0, 1, 0],
worldUpVector=worldUpVector,
worldUpType='vector')
mc.delete(constBuffer[0])
# Follow Groups
mainOrientHelperGroupBuffer = rigging.groupMeObject(mainOrientHelperObj)
mainOrientHelperGroupBuffer = NameFactory.doNameObject(
mainOrientHelperGroupBuffer)
mainOrientHelperGroup = rigging.doParentReturnName(
mainOrientHelperGroupBuffer, root)
mc.pointConstraint(objects[0],
mainOrientHelperGroupBuffer,
maintainOffset=False)
helperObjectGroups.append(mainOrientHelperGroup)
# set up constraints
mc.aimConstraint(objects[-1],
mainOrientHelperGroup,
maintainOffset=True,
weight=1,
aimVector=[1, 0, 0],
upVector=[0, 1, 0],
worldUpObject=root,
worldUpType='objectRotation')
# lock and hide stuff
attributes.doSetLockHideKeyableAttr(
mainOrientHelperObj, True, False, False,
['tx', 'ty', 'tz', 'rz', 'ry', 'sx', 'sy', 'sz', 'v'])
#>>> The sub helpers
""" make our pair lists """
pairList = lists.parseListToPairs(objects)
""" make our controls """
helperObjects = []
for pair in pairList:
""" Get Size """
size = (distance.returnBoundingBoxSizeToAverage(pair[0]) * 2)
""" make the curve"""
createBuffer = curves.createControlCurve('circleArrow2Axis', size,
'y-')
curves.setCurveColorByName(createBuffer, moduleColors[1])
""" copy the name attr"""
attributes.copyUserAttrs(pair[0], createBuffer, ['cgmName'])
attributes.storeInfo(createBuffer, 'cgmType', 'templateOrientObject')
helperObj = NameFactory.doNameObject(createBuffer)
""" store the object to it's respective object and to an object list """
attributes.storeObjectToMessage(helperObj, pair[0], 'orientHelper')
helperObjects.append(helperObj)
""" initial snapping """
position.movePointSnap(helperObj, pair[0])
constBuffer = mc.aimConstraint(pair[1],
helperObj,
maintainOffset=False,
weight=1,
aimVector=[1, 0, 0],
upVector=[0, 1, 0],
worldUpVector=worldUpVector,
worldUpType='vector')
mc.delete(constBuffer[0])
""" follow groups """
helperGroupBuffer = rigging.groupMeObject(helperObj)
helperGroup = NameFactory.doNameObject(helperGroupBuffer)
helperGroup = rigging.doParentReturnName(helperGroup, pair[0])
helperObjectGroups.append(helperGroup)
""" set up constraints """
mc.aimConstraint(pair[1],
helperGroup,
maintainOffset=False,
weight=1,
aimVector=[1, 0, 0],
upVector=[0, 1, 0],
worldUpVector=[0, 1, 0],
worldUpObject=mainOrientHelperObj,
worldUpType='objectrotation')
""" lock and hide stuff """
helperObj = attributes.returnMessageObject(pair[0], 'orientHelper')
mc.connectAttr((visAttr), (helperObj + '.v'))
attributes.doSetLockHideKeyableAttr(
helperObj, True, False, False,
['tx', 'ty', 'tz', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'])
#>>> For the last object in the chain
for obj in objects[-1:]:
""" Get Size """
size = (distance.returnBoundingBoxSizeToAverage(obj) * 2)
""" make the curve"""
createBuffer = curves.createControlCurve('circleArrow2Axis', size,
'y-')
curves.setCurveColorByName(createBuffer, moduleColors[1])
""" copy the name attr"""
attributes.copyUserAttrs(obj, createBuffer, ['cgmName'])
attributes.storeInfo(createBuffer, 'cgmType', 'templateOrientObject')
helperObj = NameFactory.doNameObject(createBuffer)
""" store the object to it's respective object """
attributes.storeObjectToMessage(helperObj, obj, 'orientHelper')
""" initial snapping """
position.movePointSnap(helperObj, obj)
constBuffer = mc.aimConstraint(objects[-2],
helperObj,
maintainOffset=False,
weight=1,
aimVector=[1, 0, 0],
upVector=[0, 1, 0],
worldUpVector=worldUpVector,
worldUpType='vector')
mc.delete(constBuffer[0])
""" follow groups """
helperGroupBuffer = rigging.groupMeObject(helperObj)
helperGroup = NameFactory.doNameObject(helperGroupBuffer)
helperGroup = rigging.doParentReturnName(helperGroup, obj)
helperObjectGroups.append(helperGroup)
""" set up constraints """
secondToLastHelperObject = attributes.returnMessageObject(
objects[-2], 'orientHelper')
mc.orientConstraint(secondToLastHelperObject,
helperGroup,
maintainOffset=False,
weight=1)
""" lock and hide stuff """
helperObj = attributes.returnMessageObject(obj, 'orientHelper')
mc.connectAttr((visAttr), (helperObj + '.v'))
attributes.doSetLockHideKeyableAttr(
helperObj, True, False, False,
['tx', 'ty', 'tz', 'sx', 'sy', 'sz', 'v'])
helperObjects.append(helperObj)
returnBuffer.append(helperObjects)
returnBuffer.append(helperObjectGroups)
return returnBuffer
