def add_to_layer(nodes, layer_name):
"""
Adds a node to the layer with the given name. If that layer does not
exist it will be created with default options.
:param nodes: List of nodes (or a single node)
:type nodes: pm.nt.Transform or list(pm.nt.Transform, ..)
:param layer_name: Name of layer to add to
:type layer_name: str
:return: None
"""
# -- If the layer does not exist, we need to create it
if not pm.ls(layer_name, type='displayLayer'):
pm.createDisplayLayer(
name=layer_name,
empty=True,
)
if not nodes:
return
# -- If the nodes is a list a single node we should convert
# -- that to a list
nodes = [nodes]
# -- Get the layer
layer = pm.PyNode(layer_name)
layer.addMembers(nodes)
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 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 setButtonPress(self, *args):
"""Sets the plane we'll be snapping to from the three selected vertices
Called by "set plane" button
"""
sel = pm.ls(selection=1, flatten=1)
if len(sel) ==3:
self.cleanUp()
pos1 = sel[0].getPosition()
pos2 = sel[1].getPosition()
pos3 = sel[2].getPosition()
vct1 = pos2-pos1
vct2 = pos3-pos1
# ^ is owerwritten to perform a cross product
self.normal = vct1 ^ vct2
self.normal.normalize()
self.position = pos1
pm.select(sel)
layerObj = pm.createDisplayLayer(name=self.layername, empty=1)
for i, vtx in enumerate(sel):
annotation = pm.annotate(vtx, tx="V%d" % (i+1), p=vtx.getPosition(space="world") )
annotation.setAttr("overrideEnabled", 1)
annotation.setAttr("overrideColor", 17)
annTrans = annotation.getParent()
annTrans.rename("annotateVts%d" % (i+1))
layerObj.addMembers(annTrans)
layerObj.addMembers(annotation)
layerObj.setAttr("displayType", 1)
else:
pm.confirmDialog(message="Please select exactly 3 vertices", title="Error", button="OK",
defaultButton="OK", dismissString="OK", cancelButton="OK")
def run():
needLayer = pm.ls(sl=True)
for x in needLayer:
ns = x.name().rpartition(':')[0]
pm.select(x)
layer = pm.createDisplayLayer(name=ns + '_layer')
pm.PyNode(layer).attr('visibility').set(False)
def createDisplayLayer(self):
"""
Create display layer and set it to wireframe mode
"""
layer = pm.createDisplayLayer(n=self.displayLayerName)
# set display type to wireframe only
layer.setAttr('displayType', 1)
return layer
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 createDisplayLayer(self):
"""
Create display layer and set it to wireframe mode
"""
layer = pm.createDisplayLayer(n=self.displayLayerName)
# set display type to wireframe only
layer.setAttr('displayType', 1)
return layer
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 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 selectCmd(*args, **kwargs):
'''
add selection model into the display layer
'''
exportLayerName = 'kx_cloth_export_layer'
if pm.objExists(exportLayerName):
exportLayer = pm.PyNode(exportLayerName)
else :
exportLayer = pm.createDisplayLayer(noRecurse = 1, e = 1, name = 'kx_cloth_export_layer')
exportLayer.visibility.set(0)
exportLayer.color.set(14)
sel = pm.ls(sl=1)
exportLayer.addMembers(sel)
return exportLayerName
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 putInLayer(objs, layerName):
'''
Puts the given objects in a layer of the given name.
todo::
There needs to be a fallback if the layer isn't found to verify another
dag obj doesn't have the intended name.
'''
for layer in ls(type='displayLayer'):
if layer.name() == layerName:
break
else:
layer = createDisplayLayer(name=layerName, e=True)
layer.addMembers(objs)
def selectCmd(*args, **kwargs):
'''
add selection model into the display layer
'''
exportLayerName = 'kx_cloth_export_layer'
if pm.objExists(exportLayerName):
exportLayer = pm.PyNode(exportLayerName)
else:
exportLayer = pm.createDisplayLayer(noRecurse=1,
e=1,
name='kx_cloth_export_layer')
exportLayer.visibility.set(0)
exportLayer.color.set(14)
sel = pm.ls(sl=1)
exportLayer.addMembers(sel)
return exportLayerName
def setPanelLayout(self):
cmd = 'setNamedPanelLayout "Single Perspective View";'
panel_current = cmds.getPanel(withFocus=1)
print 'panel_current', panel_current
#lookThroughModelPanel $cams[0] $currentPanel;
cmd += 'lookThroughModelPanel ' + self.Cam + ' ' + panel_current + ';'
pm.mel.eval(cmd)
#modelEditor -e -udm false $currentPanel;
#modelEditor -e -allObjects 0 $currentPanel;
#modelEditor -e -polymeshes true $currentPanel;
cmds.modelEditor(panel_current, e=1, udm=0)
cmds.modelEditor(panel_current, e=1, allObjects=0)
cmds.modelEditor(panel_current, e=1, polymeshes=1)
cmds.modelEditor(panel_current, e=1, cameraName=self.Cam)
#select -r `ls -dag -lf -type softModHandle -type clusterHandle` ;
#string $layer = `createDisplayLayer -name "softHandle_layer" -number 1 -nr`;
#layerEditorLayerButtonVisibilityChange $layer;
#remove cluster and softModHandle
pm.ls(dag=1, lf=1, type=('softModHandle', 'clusterHandle'))
layer = pm.createDisplayLayer(name='softHandle_layer', number=1, mc=1)
pm.mel.eval('layerEditorLayerButtonVisibilityChange ' + layer)
def setPanelLayout(self):
cmd = 'setNamedPanelLayout "Single Perspective View";'
panel_current = cmds.getPanel(withFocus=1)
print 'panel_current',panel_current
#lookThroughModelPanel $cams[0] $currentPanel;
cmd += 'lookThroughModelPanel ' + self.Cam + ' ' + panel_current + ';'
pm.mel.eval(cmd)
#modelEditor -e -udm false $currentPanel;
#modelEditor -e -allObjects 0 $currentPanel;
#modelEditor -e -polymeshes true $currentPanel;
cmds.modelEditor(panel_current,e=1,udm=0)
cmds.modelEditor(panel_current,e=1,allObjects=0)
cmds.modelEditor(panel_current,e=1,polymeshes=1)
cmds.modelEditor(panel_current,e=1,cameraName=self.Cam)
#select -r `ls -dag -lf -type softModHandle -type clusterHandle` ;
#string $layer = `createDisplayLayer -name "softHandle_layer" -number 1 -nr`;
#layerEditorLayerButtonVisibilityChange $layer;
#remove cluster and softModHandle
pm.ls(dag=1,lf=1,type=('softModHandle','clusterHandle'))
layer = pm.createDisplayLayer(name='softHandle_layer',number=1,mc=1)
pm.mel.eval('layerEditorLayerButtonVisibilityChange ' + layer)
def addToLayer(self, allObjects):
# create new display layer
layer = pm.createDisplayLayer( empty=True, name='Filterrr_layer_' )
for obj in allObjects:
pm.editDisplayLayerMembers( layer, obj )
# Looping through all assemblies
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 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 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_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 addObjectToLayer(layer='main', mode=0):
'''
assembly references can not be added to display layer, so we add text description to layer attribute
mode 0: add object
mode 1: delete object
mode 2: delete all objects in all layers
'''
layer = 'stereo_' + layer
if mode==2:
for l in ['stereo_main', 'stereo_near', 'stereo_far']:
if not pm.objExists(l):
continue
tmp = pm.PyNode(l)
obj_display = pm.listConnections(tmp.attr('drawInfo'), d=True)
for o in obj_display:
try:
tmp.drawInfo // o.drawOverride
o.attr('overrideVisibility').set(1)
o.attr('overrideEnabled').set(0)
except:
pass
if not pm.hasAttr(tmp, 'stereo_hidden'):
continue
obj_string = tmp.attr('stereo_hidden').get()
if obj_string:
obj_string = [o.strip() for o in obj_string.split(';')]
for o in obj_string:
try:
if not pm.objExists(o):
continue
o.attr('overrideVisibility').set(1)
o.attr('overrideEnabled').set(0)
except:
pass
tmp.attr('stereo_hidden').set('')
if not pm.objExists(str(layer)):
layer = pm.createDisplayLayer(name=str(layer), e=True)
else:
layer = pm.PyNode(str(layer))
if not pm.hasAttr(layer, 'stereo_hidden'):
pm.addAttr(layer, ln='stereo_hidden', dt='string')
hidden_obj = []
hidden_string = []
# get original
hidden_obj.extend( pm.listConnections(layer.attr('drawInfo'), d=True) )
hidden_string_orig = layer.attr('stereo_hidden').get()
if hidden_string_orig:
hidden_string.extend( [o.strip() for o in hidden_string_orig.split(';')] )
sel = pm.ls(sl=True)
for s in sel:
# does it ends with :master or _AR
if not s.name().endswith(':master') and not s.name().endswith('_AR'):
# is it sit in lay
if not s.isChildOf('|assets|lay'):
print s.name()+' was not added to hidden layer, because its name does not ends with :master'
return
if mode==0:
# try add to display layer first
add_to_display = False
if s not in hidden_obj:
try:
layer.drawInfo >> s.drawOverride
add_to_display = True
except:
add_to_display = False
if not add_to_display and s.name() not in hidden_string:
hidden_string.append(s.name())
elif mode==1:
if s in hidden_obj:
try:
layer.drawInfo // s.drawOverride
s.attr('overrideVisibility').set(1)
s.attr('overrideEnabled').set(0)
except:
pass
if s.name() in hidden_string:
hidden_string.remove(s.name())
layer.attr('stereo_hidden').set( ';'.join(hidden_string) )
def rigDazFigure(
name,
path='C:/Users/Darrick/Documents/Maya/projects/_UE4-Chars/scenes'):
"""Need to load DAZ FBX first"""
figure = getFigureName()
# File paths
mesh_path = '{0}/Mesh/Ref/Mesh_{1}.ma'.format(path, name)
rig_path = '{0}/Rig/Ref/Rig_{1}.ma'.format(path, name)
skel_path = '{0}/Rig/Ref/Skel_{1}.ma'.format(path, name)
anim_path = '{0}/Rig/Ref/AnimRig_{1}.mb'.format(path, name)
# Build and save meshes
print('Converting DAZ figure geometry:')
buildDazMeshes()
print('Exporting geometry...')
meshes = pm.ls(('*Mesh', '*Morphs'), type='transform', r=True)
face_sets = pm.ls('Fac*', recursive=True)
pm.select(meshes + face_sets, ne=True)
pm.exportSelected(mesh_path, force=True)
print('Geometry exported to {}'.format(mesh_path))
# Load and setup AS5 skeleton
print('Loading and setting up AS5 skeleton...')
as5util.preBuild(figure, load=True)
# Edit joint placement, if necessary
# Remove shading face sets from namespaces so they don't get deleted
for sel_set in pm.ls('Fac*', recursive=True):
pm.rename(sel_set, sel_set.name().split(':')[1])
# Delete geometry + namespaces
for name_space in 'HeadGeo', 'BodyGeo':
pm.namespace(rm=name_space, deleteNamespaceContent=True)
# Reference geometry
pm.createReference(mesh_path, defaultNamespace=True)
# Build AS5 rig
print('Building AS5 rig...')
pm.mel.eval(
'source "C:/Users/Darrick/Documents/Maya/scripts/AdvancedSkeleton5.mel";'
)
pm.mel.eval('asBuildAdvancedSkeleton();')
print('Executing post-build script...')
as5util.postBuild(figure)
pm.mel.eval('asSetBuildPose("");')
# Skin mesh and apply blendshapes
print('Skinning geometry and applying weight drivers...')
applySkins()
# Add to layers, cleanup
print('Cleaning up...')
layer = pm.ls('GeoLayer')[0] if pm.ls(
'GeoLayer') else pm.createDisplayLayer(name='GeoLayer')
layer.displayType.set(2)
for grp in pm.ls(('Mesh', 'Morphs'), r=True):
grp.setParent('Geometry')
layer.addMembers(grp)
pm.delete('Genesis8*')
for grp in 'Geometry', 'DeformationSystem':
pm.parent(grp, None)
# Export skeleton
print('Exporting skeleton to {}'.format(skel_path))
pm.select('DeformationSystem', r=True)
pm.exportSelected(skel_path, force=True, channels=False)
# Save rig file
print('Saving rig file to {}'.format(rig_path))
pm.saveAs(rig_path)
print('Saving animRig file to {}'.format(anim_path))
refs = pm.ls(type='reference')
for ref in refs:
file_ref = pm.FileReference(ref)
file_ref.importContents()
pm.saveAs(anim_path)
pm.openFile(rig_path, force=True)
print('Conversion complete.')
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
def build_base_rig():
##### 2. BUILD THE BASE RIG #####
#TODO: Generate my own generic shapes here.
#TODO: Better naming conventions
#TODO: If the guide doesn't exist, just build a rig with all controls at 0,0,0. Don't be an ass about it.
#nSRT = 'globalsrt'
nGlobal = 'world_ctl'
nLocal = 'master_C0_ctl'
nBody = 'COG_C0_ctl'
if not pm.objExists("Rig"):
rigGroup = pm.group(em=True, n='Rig')
else:
rigGroup = pm.PyNode("Rig")
if pm.objExists('RigLayer'):
pm.delete('RigLayer')
if pm.objExists('GeoLayer'):
pm.delete('GeoLayer')
oLayer = pm.createDisplayLayer('Rig', n='RigLayer', number=1, nr=True)
oLayer.color.set(14)
oLayer = pm.createDisplayLayer(pm.ls('Geo'),
n='GeoLayer',
number=1,
nr=True)
oLayer.color.set(7)
# Find or create the guide controls
#if pm.objExists(nSRT):
# oSRT = pm.PyNode(nSRT)
#else:
# oSRT = pm.spaceLocator(n='globalsrt')
if pm.objExists(nGlobal):
oGlobal = pm.PyNode(nGlobal)
else:
oGlobal = props_icon_lib.create_control_icon('arrowBox', 'world_ctl',
[10.0, 1.0, 10.0])
if pm.objExists(nLocal):
oLocal = pm.PyNode(nLocal)
else:
oLocal = props_icon_lib.create_control_icon('square', 'master_C0_ctl',
[9.0, 1.0, 9.0])
localBB = oLocal.getBoundingBox()
localWidth = localBB.width() - 1.0
localDepth = localBB.depth() - 1.0
oLocal2 = props_icon_lib.create_control_icon(
'square',
'local_C0_ctl',
[localWidth, 1.0, localDepth],
offset=[0.0, 0.2, 0.0],
)
oLocal2.setTranslation(oLocal.getTranslation(space='world'), space='world')
if pm.objExists(nBody):
oBody = pm.PyNode(nBody)
else:
oBody = props_icon_lib.create_control_icon('square', 'COG_C0_ctl',
[8.0, 1.0, 8.0])
oBody.setTranslation([0.0, 3.0, 0.0])
bodyBB = oBody.getBoundingBox()
bodyWidth = bodyBB.width() - 1.0
bodyDepth = bodyBB.depth() - 1.0
oBody2 = props_icon_lib.create_control_icon(
'square',
'COG_C1_ctl',
[bodyWidth, 1.0, bodyDepth],
offset=[0.0, 0.0, 0.0],
)
oBody2.setTranslation(oBody.getTranslation(space='world'), space='world')
#chain_parent([rigGroup, oSRT, oGlobal, oLocal, oBody, oBody2])
chain_parent([rigGroup, oGlobal, oLocal, oLocal2, oBody, oBody2])
make_a_root([oGlobal, oLocal, oLocal2, oBody, oBody2])
pm.parentConstraint(oBody2, "Geo", mo=True)
pm.scaleConstraint(oBody2, "Geo", mo=True)
oGlobal.getShape().overrideEnabled.set(True)
oLocal.getShape().overrideEnabled.set(True)
oLocal2.getShape().overrideEnabled.set(True)
oBody.getShape().overrideEnabled.set(True)
oBody2.getShape().overrideEnabled.set(True)
oGlobal.getShape().overrideColor.set(13)
oLocal.getShape().overrideColor.set(22)
oLocal2.getShape().overrideColor.set(22)
oBody.getShape().overrideColor.set(24)
oBody2.getShape().overrideColor.set(24)
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)
