def remove_from_all_layer(self, target):
target = pm.PyNode(target)
target_list = []
target_list.append(target)
target_list.append(target.getShapes())
for item in target_list:
pm.editDisplayLayerMembers('defaultLayer', item)
def saveReferenceName(pReferenceObject, *pArgs):
newLayer = pm.createDisplayLayer(name='Scan')
if (newLayer == 'Scan1'):
pm.delete('Scan1')
pm.editDisplayLayerMembers('Scan', pReferenceObject)
myDescription = pm.textField("referenceDescription", query=True, text=True)
pm.rename('%s' % (pReferenceObject), 'Scan_%s' % (myDescription))
pm.deleteUI('referenceID')
def moveToLayer(layerName, objectList=[]):
"""This function takes a set of objects and puts them onto
a designated layer. If the layer does not yet exist, it is created.
"""
if pm.objExists(layerName) == False: # the layer does not exist
pm.select(objectList)
pm.createDisplayLayer(name=layerName)
else: # the layer already exists
pm.editDisplayLayerMembers(layerName, objectList)
def moveToLayer(layerName, objectList=[]):
"""This function takes a set of objects and puts them onto
a designated layer. If the layer does not yet exist, it is created.
"""
if pm.objExists(layerName) == False: # the layer does not exist
pm.select(objectList)
pm.createDisplayLayer(name=layerName)
else: # the layer already exists
pm.editDisplayLayerMembers( layerName, objectList )
def run(self):
layer = pm.ls(self.name)
if len(layer) and isinstance(layer[0], pm.nt.DisplayLayer):
pm.editDisplayLayerMembers(layer[0], self.objects)
layer = layer[0]
else:
layer = pm.createDisplayLayer(self.objects, n=self.name)
layer.visibility.set(self.visible)
layer.displayType.set(self.displayType)
layer.shading.set(self.shading)
layer.texturing.set(self.texturing)
layer.playback.set(self.playback)
def reference_layer(object, **kwargs):
"""
Creates reference layer "Ref_Layer" if not already made or no new name is provided
Adds object to new layer
Returns new reference layer
"""
layer = kwargs.setdefault('name', 'Ref_Layer')
if py.objExists(layer) is False:
py.createDisplayLayer(empty=True, n=layer)
py.setAttr(layer+".dt", 2)
py.editDisplayLayerMembers(layer, object)
return layer
def flipAll(self, args):
layer = self.getAnim('Foxo_Controls')
controls = pm.editDisplayLayerMembers(layer, q=True)
toFlipControls = []
for control in controls:
if '_r_' not in str(control):
toFlipControls.append(control)
for control in toFlipControls:
self.flipAnim(control)
def mirrorAllRL(self, args):
layer = self.getAnim('Foxo_Controls')
controls = pm.editDisplayLayerMembers(layer, q=True)
leftControls = []
for control in controls:
if '_r_' in str(control):
leftControls.append(control)
for control in leftControls:
self.mirrorAnim(control)
def importCallback(*Args):
loadPopup = pm.confirmDialog(title='Import',
message='Choose Gender: ',
button=['Female', 'Male', 'Cancel'],
dismissString='Cancel')
global globalGender
localGender = ''
if loadPopup == 'Cancel':
return
else:
cmds.NewScene()
globalNameKey[:] = []
globalVertexKey[:] = []
if loadPopup == 'Female':
pm.mel.FBXImport(f="assets\EqualReality\NudeFemale.fbx")
localGender = 'Female'
pm.move('persp', [0, 156, 89])
if loadPopup == 'Male':
pm.mel.FBXImport(f="assets\EqualReality\NudeMale.fbx")
localGender = 'Male'
pm.move('persp', [0, 169, 89])
pm.rotate('persp', [-8, 0, 0])
myScene = ['Eyes', 'Eyelashes', 'Body_%s' % (localGender)]
pm.createDisplayLayer(name='Game_Model', number=1)
for item in myScene:
pm.editDisplayLayerMembers('Game_Model', item)
#pm.hide('mixamorig:Hips')
pm.hide('Eyes')
global OnStart
OnStart = 1
pm.modelEditor('modelPanel4', edit=True, displayTextures=True)
rolloutParameters(names=[None], edit=True)
createUI('Poly Morph')
def deleteLayers():
"""
delete selected display layers
:return:
"""
type = getLayerDisplayType()
if type != "Display":
pm.warning("Unsupported layer type. Works on display layers.")
return []
selectedLayers = getLayerSelection()
for layer in selectedLayers:
objs = pm.editDisplayLayerMembers(layer, query=True, fullNames=True)
pm.delete(layer)
if objs:
for obj in objs:
pm.setAttr(obj + ".overrideEnabled", 0)
def postbuild(self):
# Group everything
all_anms = libPymel.ls_root_anms()
if not isinstance(self.grp_anms, CtrlRoot):
self.grp_anms = CtrlRoot()
self.grp_anms.build()
self.grp_anms.rename('anm_root')
all_anms.setParent(self.grp_anms)
all_rigs = libPymel.ls_root_rigs()
self.grp_rigs = RigNode(name='rigs', _create=True)
all_rigs.setParent(self.grp_rigs)
# note: self.grp_jnts is now handled in prebuild
#all_jnts = libPymel.ls_root_jnts()
#self.grp_jnts = pymel.createNode('joint', name='jnts')
#all_jnts.setParent(self.grp_jnts)
# Ensure self.grp_jnts is constraint to self.grp_anms
# We use parentConstraint instead of connections in the the animator change self.grp_anms parent
pymel.delete([child for child in self.grp_jnts.getChildren() if isinstance(child, pymel.nodetypes.Constraint)])
pymel.parentConstraint(self.grp_anms, self.grp_jnts)
all_geos = libPymel.ls_root_geos()
self.grp_geos = RigNode(name='geos', _create=True)
all_geos.setParent(self.grp_geos)
# Setup displayLayers
self.layer_anm = pymel.createDisplayLayer(name='layer_anm', number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anms, noRecurse=True)
self.layer_anm.color.set(17) # Yellow
self.layer_rig = pymel.createDisplayLayer(name='layer_rig', number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rigs, noRecurse=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnts, noRecurse=True)
self.layer_rig.color.set(13) # Red
#oLayerRig.visibility.set(0) # Hidden
self.layer_rig.displayType.set(2) # Frozen
self.layer_geo = pymel.createDisplayLayer(name='layer_geo', number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geos, noRecurse=True)
self.layer_geo.color.set(12) # Green?
self.layer_geo.displayType.set(2) # Frozen
def pre_build(self, create_master_grp=False, create_grp_jnt=True, create_grp_anm=True,
create_grp_rig=True, create_grp_geo=True, create_display_layers=True, create_grp_backup=False):
# Hack: Invalidate any cache before building anything.
# This ensure we always have fresh data.
try:
del self._cache
except AttributeError:
pass
# Look for a root joint
if create_grp_jnt:
# For now, we will determine the root jnt by it's name used in each rig. Not the best solution,
# but currently the safer since we want to support multiple deformation layer
if not libPymel.is_valid_PyNode(self.grp_jnt):
# self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None)
if cmds.objExists(self.nomenclature.root_jnt_name):
self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name)
else:
self.warning("Could not find any root joint, master ctrl will not drive anything")
# self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name)
# Ensure all joints have segmentScaleComprensate deactivated.
# This allow us to scale adequately and support video game rigs.
# If for any mean stretch and squash are necessary, implement
# them on a new joint chains parented to the skeletton.
# TODO: Move elsewere?
all_jnts = libPymel.ls(type='joint')
for jnt in all_jnts:
jnt.segmentScaleCompensate.set(False)
# Create the master grp
if create_master_grp:
self.grp_master = self.build_grp(RigGrp, self.grp_master, self.name + '_' + self.nomenclature.type_rig)
# Create grp_anm
if create_grp_anm:
grp_anim_size = CtrlRoot._get_recommended_radius(self)
self.grp_anm = self.build_grp(CtrlRoot, self.grp_anm, self.nomenclature.root_anm_name, size=grp_anim_size)
# Create grp_rig
if create_grp_rig:
self.grp_rig = self.build_grp(RigGrp, self.grp_rig, self.nomenclature.root_rig_name)
# Create grp_geo
if create_grp_geo:
all_geos = libPymel.ls_root_geos()
self.grp_geo = self.build_grp(RigGrp, self.grp_geo, self.nomenclature.root_geo_name)
#if all_geos:
# all_geos.setParent(self.grp_geo)
if create_grp_backup:
self.grp_backup = self.build_grp(RigGrp, self.grp_backup, self.nomenclature.root_backup_name)
#Parent all grp on the master grp
if self.grp_master:
if self.grp_jnt:
self.grp_jnt.setParent(self.grp_master.node)
if self.grp_anm:
self.grp_anm.setParent(self.grp_master.node)
if self.grp_rig:
self.grp_rig.setParent(self.grp_master.node)
if self.grp_geo:
self.grp_geo.setParent(self.grp_master.node)
if self.grp_backup:
self.grp_backup.setParent(self.grp_master.node)
# Setup displayLayers
if create_display_layers:
if not pymel.objExists(self.nomenclature.layer_anm_name):
self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True)
self.layer_anm.color.set(17) # Yellow
else:
self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name)
pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_rig_name):
self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True)
self.layer_rig.color.set(13) # Red
# self.layer_rig.visibility.set(0) # Hidden
self.layer_rig.displayType.set(2) # Frozen
else:
self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_geo_name):
self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True)
self.layer_geo.color.set(12) # Green?
self.layer_geo.displayType.set(2) # Frozen
else:
self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name)
pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True)
def addToLayer(self, allObjects):
# create new display layer
layer = pm.createDisplayLayer( empty=True, name='Filterrr_layer_' )
for obj in allObjects:
pm.editDisplayLayerMembers( layer, obj )
def ph_mainCode(extraHeight, particleRate, getInitialInfo, minSlope,
minSlopeVariance, setBoundingBox, maxTilt, objectScale,
objectScaleVariance, objectHeightVariance):
displayWindow = True
windowError = py.window(title="Notice", mxb=False, s=False)
errorLayout = py.rowColumnLayout(numberOfColumns=3, parent=windowError)
#initialise varibables
originalTime = py.currentTime(query=True)
deleteCount = 0
decimalPoints = 2
#file validation
storeSelection = py.ls(selection=True)
try:
validFile = True
myfile = open('storedobjects.txt')
objectList = myfile.readlines()
myfile.close()
py.select(clear=True)
for i in range(len(objectList)):
py.select(objectList[i], add=True)
1 / len(objectList)
except:
validFile = False
#get original selection
py.select(clear=True)
for i in range(len(storeSelection)):
py.select(storeSelection[i], add=True)
#deselect non polygons
if type(storeSelection[i]) != py.nodetypes.Transform:
py.select(storeSelection[i], deselect=True)
#deselect objects in the text file
if getInitialInfo == False:
for j in range(len(objectList)):
selectionEdit = storeSelection[i] + objectList[j][
-2] + objectList[j][-1]
if objectList[j] == selectionEdit:
py.select(storeSelection[i], deselect=True)
storeSelection = py.ls(selection=True)
startTime = time()
listOfPoints = []
totalNum = 0
if len(storeSelection) == 0:
displayMessage = "Nothing is selected. Please select an object and try again."
ph_displayWindow(displayWindow, displayMessage)
elif getInitialInfo == True:
#write to file
selection = py.ls(selection=True)
myfile = open('storedobjects.txt', 'w')
for i in range(len(selection)):
myfile.write("" + selection[i] + "\r\n")
myfile.close()
if len(selection) > 0:
print str(len(selection)) + " object(s) successfully stored."
if displayWindow == True:
py.text(label=" ")
py.text(label=" ")
py.text(label=" ")
py.text(label=" ")
py.text(label=str(len(selection)) +
" object(s) successfully stored.",
align="center")
py.text(label=" ")
py.text(label=" ")
py.text(label=" ")
py.text(label=" ")
py.showWindow()
else:
displayMessage = "Please select the objects you wish to store."
ph_displayWindow(displayWindow, displayMessage)
for i in range(len(storeSelection)):
py.select(storeSelection[i], add=True)
elif validFile == False:
displayMessage = "Error with stored list. Please choose new object(s) to duplicate."
ph_displayWindow(displayWindow, displayMessage)
elif len(objectList) == 0:
displayMessage = "No objects stored. Please choose new object(s) to duplicate."
ph_displayWindow(displayWindow, displayMessage)
else:
for loops in range(len(storeSelection)):
particleID = []
particleLoc = []
particleVelocity = []
#get information about selected object
py.select(storeSelection[loops], r=True)
originalObj = py.ls(selection=True)
originalObjLoc = originalObj[0].getTranslation()
originalObjX = originalObjLoc.x
originalObjY = originalObjLoc.y
originalObjZ = originalObjLoc.z
#duplicate object to work on
tempObj = py.instance(originalObj)
#make emitter
particleEmitter = py.emitter(n='tempEmitter',
type='surface',
r=particleRate * 24,
sro=0,
speed=0.0001)
particles = py.particle(n='emittedParticles')
py.connectDynamic('emittedParticles', em='tempEmitter')
py.setAttr(particles[1] + '.seed[0]', rd.randint(0, sys.maxint))
#get list from file
myfile = open('storedobjects.txt')
objectList = myfile.readlines()
objectListCopy = []
myfile.close()
for i in range(len(objectList)):
copyObj = py.duplicate(objectList[i])
objectListCopy.append(copyObj)
#fixes the seed always being 0
py.currentTime(originalTime + 1, edit=True, update=True)
py.currentTime(originalTime, edit=True, update=True)
py.currentTime(originalTime + 1, edit=True, update=True)
numOfParticles = particles[1].num()
for i in range(numOfParticles):
#get particle info
particleInfo = particles[1].Point('emittedParticles', i)
particleID.append(particleInfo)
particleLoc.append(particleInfo.position)
particleVelocity.append(particleInfo.velocity)
for i in range(len(particleID)):
#place objects
randomNum = rd.randint(0, len(objectListCopy) - 1)
instanceObj = objectListCopy[randomNum]
dupObj = py.instance(instanceObj)
yDir = particleVelocity[i][1] * 10000
#get height of object
py.select(instanceObj, r=True)
py.scale(1, 1, 1)
height = py.ls(selection=True)[0].getBoundingBox().height()
#reselect instance
py.select(dupObj[0], r=True)
py.move(dupObj[0], particleLoc[i][0],
particleLoc[i][1] + extraHeight, particleLoc[i][2])
py.rotate(dupObj[0],
rd.uniform(-maxTilt, maxTilt),
rd.randint(0, 360),
rd.uniform(-maxTilt, maxTilt),
os=True)
scaleX = rd.uniform(objectScale - objectScaleVariance,
objectScale + objectScaleVariance)
scaleY = rd.uniform(objectScale - (objectHeightVariance / 2),
objectScale + objectHeightVariance)
scaleZ = rd.uniform(objectScale - objectScaleVariance,
objectScale + objectScaleVariance)
py.scale(dupObj[0], scaleX, scaleY, scaleZ)
if yDir <= rd.uniform(minSlope - minSlopeVariance,
minSlope + minSlopeVariance):
py.delete(dupObj)
deleteCount = deleteCount + 1
else:
listOfPoints.append(dupObj)
#display percent completed
maxValue = int(pow(len(particleID), 0.5))
if float(i / maxValue) == float(i) / maxValue:
print str(
int((float(i) * 100 / len(particleID)) * 100.0) /
100.0) + "% completed"
totalNum = totalNum + numOfParticles
#delete temp objects
py.select(tempObj, 'tempEmitter', 'emittedParticles')
py.delete()
py.currentTime(originalTime, edit=True, update=True)
for i in range(len(objectListCopy)):
py.delete(objectListCopy[i][0])
#place objects in display layer
py.select(clear=True)
if len(listOfPoints) > 0:
if setBoundingBox == True:
displayLayerName = 'duplicatedObjectsBB'
else:
displayLayerName = 'duplicatedObjectsMesh'
#add to display layer
try:
for i in range(len(listOfPoints)):
py.editDisplayLayerMembers(displayLayerName, listOfPoints[i])
#create display layer first
except:
py.createDisplayLayer(noRecurse=True, name=displayLayerName)
for i in range(len(listOfPoints)):
py.editDisplayLayerMembers(displayLayerName, listOfPoints[i])
#display objects as bounding box
if setBoundingBox == True:
py.setAttr(displayLayerName + '.levelOfDetail', 1)
py.setAttr(displayLayerName + '.color', 17)
#add to group
for i in range(len(listOfPoints)):
py.select(listOfPoints[i][0], add=True)
py.group(n='duplicatedObjectsGroup')
#output time taken
endTime = time()
ph_timeOutput(startTime, endTime, decimalPoints)
secondsDecimal, sec = ph_timeOutput(startTime, endTime, decimalPoints)
displayMessage = str(totalNum -
deleteCount) + " objects created in " + str(
secondsDecimal) + str(sec)
ph_displayWindow(displayWindow, displayMessage)
#select original selection
py.select(clear=True)
for i in range(len(storeSelection)):
py.select(storeSelection[i], add=True)
def pre_build(self, create_grp_jnt=True, create_grp_anm=True, create_grp_rig=True, create_grp_geo=True, create_display_layers=True):
# Ensure we got a root joint
# If needed, parent orphan joints to this one
if create_grp_jnt:
if not libPymel.is_valid_PyNode(self.grp_jnt):
self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None)
'''
if cmds.objExists(self.nomenclature.root_jnt_name):
self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name)
else:
self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name)
'''
#all_root_jnts.setParent(self.grp_jnt)
# Ensure all joinst have segmentScaleComprensate deactivated.
# This allow us to scale adequately and support video game rigs.
# If for any mean stretch and squash are necessary, implement them on a new joint chains parented to the skeletton.
# TODO: Move elsewere?
all_jnts = libPymel.ls(type='joint')
for jnt in all_jnts:
jnt.segmentScaleCompensate.set(False)
# Create grp_anm
if create_grp_anm:
if not isinstance(self.grp_anm, CtrlRoot):
self.grp_anm = CtrlRoot()
if not self.grp_anm.is_built():
grp_anm_size = CtrlRoot._get_recommended_radius(self)
self.grp_anm.build(self, size=grp_anm_size)
self.grp_anm.rename(self.nomenclature.root_anm_name)
# Create grp_rig
if create_grp_rig:
if not isinstance(self.grp_rig, Node):
self.grp_rig = Node()
if not self.grp_rig.is_built():
self.grp_rig.build(self)
self.grp_rig.rename(self.nomenclature.root_rig_name)
# Create grp_geo
if create_grp_geo:
all_geos = libPymel.ls_root_geos()
if not isinstance(self.grp_geo, Node):
self.grp_geo = Node()
if not self.grp_geo.is_built():
self.grp_geo.build(self)
self.grp_geo.rename(self.nomenclature.root_geo_name)
#if all_geos:
# all_geos.setParent(self.grp_geo)
# Setup displayLayers
if create_display_layers:
if not pymel.objExists(self.nomenclature.layer_anm_name):
self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True)
self.layer_anm.color.set(17) # Yellow
if not pymel.objExists(self.nomenclature.layer_rig_name):
self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True)
self.layer_rig.color.set(13) # Red
#self.layer_rig.visibility.set(0) # Hidden
self.layer_rig.displayType.set(2) # Frozen
if not pymel.objExists(self.nomenclature.layer_geo_name):
self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True)
pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True)
self.layer_geo.color.set(12) # Green?
self.layer_geo.displayType.set(2) # Frozen
for each in assemblies:
# Checking whether each item is not in exclude list. if avaliable it will be ignored
if each not in excludeType:
# Adding each item from list if not avaliable in exclude list
finalAssemblies.append(each)
# Getting the list of catagories with out duplicates.
# empty list to store catagories
catagory = []
# Looping through final assemblies
for each in finalAssemblies:
# Splitting the name based on "_"
typ, col = each.split('_')
# Adding the typ variable to the list
catagory.append(typ)
# Removing the duplicates from generated list and assigning as a new variable.
finalCatagory = list(set(catagory))
# Looping through catagory
for eachCatagory in finalCatagory:
# Creating a new display layer with the each catagory name.
pm.createDisplayLayer(name=eachCatagory, empty=True)
# Looping through all final assemblies
for eachAssembly in finalAssemblies:
# Checking whether each assembly is starting with catagory name.
if eachAssembly.startswith(eachCatagory):
# Adding the assembly to the catagory display layer.
pm.editDisplayLayerMembers(eachCatagory, eachAssembly)
def selectAll(self, args):
layer = self.getAnim('Foxo_Controls')
pm.select(pm.editDisplayLayerMembers(layer, q=True))
def resetAll(self, args):
layer = self.getAnim('Foxo_Controls')
controls = pm.editDisplayLayerMembers(layer, q=True)
for anim in controls:
self.resetAnim(anim)
def keyAll(self, args):
layer = self.getAnim('Foxo_Controls')
controls = pm.editDisplayLayerMembers(layer, q=True)
for control in controls:
pm.setKeyframe(control)
def pre_build(self, create_master_grp=False, create_grp_jnt=True, create_grp_anm=True,
create_grp_rig=True, create_grp_geo=True, create_display_layers=True, create_grp_backup=False,
create_layer_jnt=False):
# Hack: Invalidate any cache before building anything.
# This ensure we always have fresh data.
self._clear_cache()
# Look for a root joint
if create_grp_jnt:
# For now, we will determine the root jnt by it's name used in each rig. Not the best solution,
# but currently the safer since we want to support multiple deformation layer
if not libPymel.is_valid_PyNode(self.grp_jnt):
# self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None)
if cmds.objExists(self.nomenclature.root_jnt_name):
self.grp_jnt = pymel.PyNode(self.nomenclature.root_jnt_name)
else:
self.warning("Could not find any root joint, master ctrl will not drive anything")
# self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name)
# Create the master grp
if create_master_grp:
self.grp_master = self.build_grp(RigGrp, self.grp_master, self.name + '_' + self.nomenclature.type_rig)
# Create grp_anm
if create_grp_anm:
grp_anim_size = CtrlRoot._get_recommended_radius(self)
self.grp_anm = self.build_grp(CtrlRoot, self.grp_anm, self.nomenclature.root_anm_name, size=grp_anim_size)
# Create grp_rig
if create_grp_rig:
self.grp_rig = self.build_grp(RigGrp, self.grp_rig, self.nomenclature.root_rig_name)
# Create grp_geo
if create_grp_geo:
all_geos = libPymel.ls_root_geos()
self.grp_geo = self.build_grp(RigGrp, self.grp_geo, self.nomenclature.root_geo_name)
# if all_geos:
# all_geos.setParent(self.grp_geo)
if create_grp_backup:
self.grp_backup = self.build_grp(RigGrp, self.grp_backup, self.nomenclature.root_backup_name)
# Parent all grp on the master grp
if self.grp_master:
if self.grp_jnt:
self.grp_jnt.setParent(self.grp_master.node)
if self.grp_anm:
self.grp_anm.setParent(self.grp_master.node)
if self.grp_rig:
self.grp_rig.setParent(self.grp_master.node)
if self.grp_geo:
self.grp_geo.setParent(self.grp_master.node)
if self.grp_backup:
self.grp_backup.setParent(self.grp_master.node)
# Setup displayLayers
if create_display_layers:
if not pymel.objExists(self.nomenclature.layer_anm_name):
self.layer_anm = pymel.createDisplayLayer(name=self.nomenclature.layer_anm_name, number=1, empty=True)
self.layer_anm.color.set(17) # Yellow
else:
self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name)
pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm, noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_rig_name):
self.layer_rig = pymel.createDisplayLayer(name=self.nomenclature.layer_rig_name, number=1, empty=True)
self.layer_rig.color.set(13) # Red
# self.layer_rig.visibility.set(0) # Hidden
self.layer_rig.displayType.set(2) # Frozen
else:
self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_rig, noRecurse=True)
pymel.editDisplayLayerMembers(self.layer_rig, self.grp_jnt, noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_geo_name):
self.layer_geo = pymel.createDisplayLayer(name=self.nomenclature.layer_geo_name, number=1, empty=True)
self.layer_geo.color.set(12) # Green?
self.layer_geo.displayType.set(2) # Frozen
else:
self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name)
pymel.editDisplayLayerMembers(self.layer_geo, self.grp_geo, noRecurse=True)
if create_layer_jnt:
if not pymel.objExists(self.nomenclature.layer_jnt_name):
self.layer_jnt = pymel.createDisplayLayer(name=self.nomenclature.layer_jnt_name, number=1,
empty=True)
self.layer_jnt.color.set(1) # Black?
self.layer_jnt.visibility.set(0) # Hidden
self.layer_jnt.displayType.set(2) # Frozen
else:
self.layer_jnt = pymel.PyNode(self.nomenclature.layer_jnt_name)
pymel.editDisplayLayerMembers(self.layer_jnt, self.grp_jnt, noRecurse=True)
def getObjectsInDisplayLayer(layer):
return pm.ls(pm.editDisplayLayerMembers(layer, query=True))
def pre_build(self, create_grp_anm=True, create_display_layers=True, **kwargs):
super(RigSqueeze, self).pre_build(create_grp_anm=create_grp_anm, create_master_grp=False,
create_display_layers=create_display_layers, **kwargs)
if create_grp_anm:
grp_anim_size = CtrlMaster._get_recommended_radius(self)
self.grp_anm_master = self.build_grp(
CtrlMaster,
self.grp_anm_master,
self.nomenclature.root_anm_master_name,
size=grp_anim_size
)
if create_display_layers:
pymel.editDisplayLayerMembers(self.layer_anm, self.grp_anm_master, noRecurse=True)
#
# Create specific group related to squeeze rig convention
#
all_geos = libPymel.ls_root_geos()
# Build All_Grp
self.grp_master = self.build_grp(classRig.RigGrp, self.grp_master, self.nomenclature.root_all_name)
self.grp_model = self.build_grp(classRig.RigGrp, self.grp_model, self.nomenclature.root_model_name)
self.grp_proxy = self.build_grp(classRig.RigGrp, self.grp_proxy, self.nomenclature.root_proxy_name)
self.grp_fx = self.build_grp(classRig.RigGrp, self.grp_fx, self.nomenclature.root_fx_name)
# Parent all groups in the main grp_master
pymel.parent(self.grp_anm_master, self.grp_master)
pymel.parent(self.grp_anm, self.grp_anm_master) # grp_anm is not a Node, but a Ctrl
self.grp_rig.setParent(self.grp_master)
self.grp_fx.setParent(self.grp_master)
self.grp_model.setParent(self.grp_master)
self.grp_proxy.setParent(self.grp_master)
self.grp_geo.setParent(self.grp_master)
'''
if self.grp_jnt.getParent() is None:
self.grp_jnt.setParent(self.grp_master)
'''
# Lock and hide all attributes we don't want the animator to play with
libAttr.lock_hide_trs(self.grp_master)
libAttr.lock_hide_trs(self.grp_rig)
libAttr.lock_hide_trs(self.grp_fx)
libAttr.lock_hide_trs(self.grp_model)
libAttr.lock_hide_trs(self.grp_proxy)
libAttr.lock_hide_trs(self.grp_geo)
libAttr.hide_scale(self.grp_anm)
# Hide some group
# self.grp_jnt.visibility.set(False)
self.grp_rig.visibility.set(False)
self.grp_fx.visibility.set(False)
self.grp_model.visibility.set(False)
#
# Add root ctrl attributes specific to squeeze while preserving existing connections.
#
if not self.grp_anm.hasAttr(self.GROUP_NAME_DISPLAY, checkShape=False):
libAttr.addAttr_separator(self.grp_anm, self.GROUP_NAME_DISPLAY)
attr_display_mesh_output_attrs = {self.grp_geo.visibility}
attr_display_proxy_output_attrs = {self.grp_proxy.visibility}
# attr_display_ctrl_output_attrs = set(
# [children.visibility for children in self.grp_anm.getChildren(type='transform')]
# )
# In the past, the displayMesh attribute was a boolean and the displayProxy was also a boolean.
# Now we use an enum. This mean that we need to remap.
if self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_MESH):
attr_display_mesh = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_MESH)
if attr_display_mesh.type() == 'short':
for attr_dst in attr_display_mesh.outputs(plugs=True):
attr_display_mesh_output_attrs.add(attr_dst)
pymel.disconnectAttr(attr_display_mesh, attr_dst)
if self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_PROXY):
attr_display_proxy = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_PROXY)
for attr_dst in attr_display_proxy.outputs(plugs=True):
attr_display_proxy_output_attrs.add(attr_dst)
pymel.disconnectAttr(attr_display_proxy, attr_dst)
attr_display_proxy.delete()
# Create DisplayMesh attribute
attr_display_mesh = self._init_attr_display_mesh()
# Create DisplayCtrl attribute
attr_display_ctrl = self._init_attr_display_ctrl()
# Connect DisplayMesh attribute
for attr_dst in attr_display_mesh_output_attrs:
if not libAttr.is_connected_to(attr_display_mesh, attr_dst, max_depth=3):
self.debug("Connecting {} to {}".format(attr_display_mesh, attr_dst))
attr_proxy_display_inn = libRigging.create_utility_node(
'condition',
firstTerm=attr_display_mesh,
secondTerm=0,
colorIfTrueR=True,
colorIfFalseR=False
).outColorR
pymel.connectAttr(attr_proxy_display_inn, attr_dst, force=True)
for attr_dst in attr_display_proxy_output_attrs:
if not libAttr.is_connected_to(attr_display_mesh, attr_dst, max_depth=3):
self.debug("Connecting {} to {}".format(attr_display_mesh, attr_dst))
# attr_proxy_display_inn = libRigging.create_utility_node(
# 'condition',
# firstTerm=attr_display_mesh,
# secondTerm=0,
# colorIfTrueR=True,
# colorIfFalseR=False
# ).outColorR
pymel.connectAttr(attr_display_mesh, attr_dst, force=True)
def pre_build(self,
create_master_grp=False,
create_grp_jnt=True,
create_grp_anm=True,
create_grp_rig=True,
create_grp_geo=True,
create_display_layers=True,
create_grp_backup=False):
# Hack: Invalidate any cache before building anything.
# This ensure we always have fresh data.
try:
del self._cache
except AttributeError:
pass
# Look for a root joint
if create_grp_jnt:
# For now, we will determine the root jnt by it's name used in each rig. Not the best solution,
# but currently the safer since we want to support multiple deformation layer
if not libPymel.is_valid_PyNode(self.grp_jnt):
# self.grp_jnt = next(iter(libPymel.ls_root(type='joint')), None)
if cmds.objExists(self.nomenclature.root_jnt_name):
self.grp_jnt = pymel.PyNode(
self.nomenclature.root_jnt_name)
else:
self.warning(
"Could not find any root joint, master ctrl will not drive anything"
)
# self.grp_jnt = pymel.createNode('joint', name=self.nomenclature.root_jnt_name)
# Ensure all joints have segmentScaleComprensate deactivated.
# This allow us to scale adequately and support video game rigs.
# If for any mean stretch and squash are necessary, implement
# them on a new joint chains parented to the skeletton.
# TODO: Move elsewere?
all_jnts = libPymel.ls(type='joint')
for jnt in all_jnts:
jnt.segmentScaleCompensate.set(False)
# Create the master grp
if create_master_grp:
self.grp_master = self.build_grp(
RigGrp, self.grp_master,
self.name + '_' + self.nomenclature.type_rig)
# Create grp_anm
if create_grp_anm:
grp_anim_size = CtrlRoot._get_recommended_radius(self)
self.grp_anm = self.build_grp(CtrlRoot,
self.grp_anm,
self.nomenclature.root_anm_name,
size=grp_anim_size)
# Create grp_rig
if create_grp_rig:
self.grp_rig = self.build_grp(RigGrp, self.grp_rig,
self.nomenclature.root_rig_name)
# Create grp_geo
if create_grp_geo:
all_geos = libPymel.ls_root_geos()
self.grp_geo = self.build_grp(RigGrp, self.grp_geo,
self.nomenclature.root_geo_name)
#if all_geos:
# all_geos.setParent(self.grp_geo)
if create_grp_backup:
self.grp_backup = self.build_grp(
RigGrp, self.grp_backup, self.nomenclature.root_backup_name)
#Parent all grp on the master grp
if self.grp_master:
if self.grp_jnt:
self.grp_jnt.setParent(self.grp_master.node)
if self.grp_anm:
self.grp_anm.setParent(self.grp_master.node)
if self.grp_rig:
self.grp_rig.setParent(self.grp_master.node)
if self.grp_geo:
self.grp_geo.setParent(self.grp_master.node)
if self.grp_backup:
self.grp_backup.setParent(self.grp_master.node)
# Setup displayLayers
if create_display_layers:
if not pymel.objExists(self.nomenclature.layer_anm_name):
self.layer_anm = pymel.createDisplayLayer(
name=self.nomenclature.layer_anm_name,
number=1,
empty=True)
self.layer_anm.color.set(17) # Yellow
else:
self.layer_anm = pymel.PyNode(self.nomenclature.layer_anm_name)
pymel.editDisplayLayerMembers(self.layer_anm,
self.grp_anm,
noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_rig_name):
self.layer_rig = pymel.createDisplayLayer(
name=self.nomenclature.layer_rig_name,
number=1,
empty=True)
self.layer_rig.color.set(13) # Red
# self.layer_rig.visibility.set(0) # Hidden
self.layer_rig.displayType.set(2) # Frozen
else:
self.layer_rig = pymel.PyNode(self.nomenclature.layer_rig_name)
pymel.editDisplayLayerMembers(self.layer_rig,
self.grp_rig,
noRecurse=True)
pymel.editDisplayLayerMembers(self.layer_rig,
self.grp_jnt,
noRecurse=True)
if not pymel.objExists(self.nomenclature.layer_geo_name):
self.layer_geo = pymel.createDisplayLayer(
name=self.nomenclature.layer_geo_name,
number=1,
empty=True)
self.layer_geo.color.set(12) # Green?
self.layer_geo.displayType.set(2) # Frozen
else:
self.layer_geo = pymel.PyNode(self.nomenclature.layer_geo_name)
pymel.editDisplayLayerMembers(self.layer_geo,
self.grp_geo,
noRecurse=True)
