def animatedVoxelization(self, name, res):
time = cmds.currentTime(q=True)
cmds.currentTime(time, e=True, u=False)
cmds.currentTime(time, e=True, u=True)
cmds.showHidden(name)
voxelGroupName = name + 'VoxelGroup'
if cmds.objExists(voxelGroupName):
cmds.delete(voxelGroupName)
meshDuplicate = cmds.duplicate(name)
cmds.makeIdentity(meshDuplicate[0],
a=True,
t=True,
r=True,
s=True,
n=0)
meshBbox = cmds.exactWorldBoundingBox(meshDuplicate[0])
cmds.delete(meshDuplicate)
cmds.voxelMesh(name, meshBbox, res)
cmds.hide(name)
def change_bbox_visibility(node_name, hide_object=False):
bbox_node = cmds.ls("{0}_BBOX".format(node_name))
if hide_object:
cmds.hide(bbox_node)
elif not hide_object:
cmds.showHidden(bbox_node)
def createMashNetwork(node, node2, transformNode):
# create a new MASH network
mashNetwork = mapi.Network()
mashNetwork.createNetwork(name="MASH")
# connect object to repro node for instancing
repro.connect_mesh_group('MASH_Repro', node)
AErepro.refresh_all_aetemplates(
) # Refresh the attribute editor for all repro nodes
#change attribute on distribute node to make object follow curve
#cmds.setAttr( 'MASH_Distribute.arrangement', 7 )
cmds.setAttr('MASH_Distribute.amplitudeX', 0)
#Create Curve Node with Curve
Curvenode = mashNetwork.addNode("MASH_Curve")
#change curve node attribute to having object duplicate around entire curve
cmds.setAttr("MASH_Curve.timeStep", 1)
bug = "MASH_Curve"
cmds.connectAttr(node2[0] + '.worldSpace[0]',
bug + ".inCurves[0]",
force=1)
cmds.showHidden(node2)
cmds.showHidden(transformNode)
def doPress(self):
# print "PRESS"
self.isMouseDown = True
am = self.activeManip()
m = Mom()
m.strandsSelected(
self.helicesNames,
(am is self.fDistanceFrontManip, am is self.fDistanceBackManip))
self.createHelixDragMarker()
selectedItems = cmds.ls(Mom().helixTransformName + "*", selection=True)
bbox = cmds.exactWorldBoundingBox(selectedItems)
cmds.setAttr(helixManip.transformName + ".scale",
bbox[3] - bbox[0],
0,
bbox[4] - bbox[1],
type="double3")
z = 0
if am is self.fDistanceFrontManip:
z = bbox[5]
elif am is self.fDistanceBackManip:
z = bbox[2]
self.moveHelixDragMarkerTo(
((bbox[0] + bbox[3]) / 2, (bbox[1] + bbox[4]) / 2, z))
cmds.showHidden(helixManip.transformName)
self.calculateDeltaBounds()
return OpenMaya.kUnknownParameter
def cleanupLayers():
#Rename/Group Simulation Objects
mc.rename('nucleus1', 'nucleus_beowulf')
mc.rename('nRigid1', 'nRigid_beowulf_body')
mc.rename('nCloth1', 'nCloth_beowulf_cape')
mc.group('dynamicConstraint1',
'dynamicConstraint2',
name='beowulf_capeConstraints')
mc.group('nucleus_beowulf',
'nRigid_beowulf_body',
'nCloth_beowulf_cape',
'beowulf_capeConstraints',
name='beowulf_cape_simulation')
#Hide Unnecessary Objects
mc.hide('beowulf_cape_model_main_beowulf_cape_simMesh')
mc.hide('beowulf_cape_model_main_beowulf_cape_clasps'
) #the chain/clasps are taken care of in the other script
mc.hide('beowulf_cape_model_main_beowulf_cape_clasp_chain')
mc.hide(
'beowulf_collision_mesh_cloth_model_main_beowulf_collision_mesh_cloth')
mc.showHidden('beowulf_cape_model_main_beowulf_cape_beautyMesh')
#Put stuff in layers:
mc.select(rigPrefix + 'Beowulf_geo_GRP_01', replace=True)
mc.select(rigPrefix + 'beowulf_capeChain_combined', add=True)
mc.createDisplayLayer(name="Beowulf_geo")
mc.select('beowulf_cape_model_main_Beowulf_Cape', replace=True)
mc.select('beowulf_cape_simulation', add=True)
mc.createDisplayLayer(name="Beowulf_cape_sim")
def sleeveTips(side):
import maya.cmds as mc
parts = [
'%s_top_sleeve_01_ctrl' % side,
'%s_topToFront_sleeve_01_interm_02_ctrl' % side,
'%s_front_sleeve_01_ctrl' % side,
'%s_frontToBot_sleeve_01_interm_02_ctrl' % side,
'%s_bot_sleeve_01_ctrl' % side,
'%s_botToBack_sleeve_01_interm_02_ctrl' % side,
'%s_back_sleeve_01_ctrl' % side,
'%s_backToTop_sleeve_01_interm_02_ctrl' % side,
]
num = '00'
for part in parts:
dup = mc.duplicate('%s_orig' % part, rc=True)
dup = dup[0]
mc.parent(dup, part)
mc.showHidden(dup)
mc.move(0.275, 0, 0, dup, r=True, os=True)
dup2 = dup.replace('01', num)
dup = mc.rename(dup, dup2[:-1])
kids = mc.listRelatives(dup, ad=True)
for kid in kids:
kid2 = kid.replace('01', num)
kid = mc.rename(kid, kid2[:-1])
def show_nodes(self,
nodes,
select_second=None,
isolate=False,
select=False):
"""Displays the desired nodes and any parent nodes that may be hidden
Args:
nodes (list): of desired nodes
isolate (bool, optional): isolate in viewport
select (bool, optional): should desired nodes be selected as well
"""
cmds.hide(cmds.listRelatives(self.root_node, ad=True,
type="transform"))
cmds.showHidden(nodes, a=True)
if select or isolate:
cmds.select(nodes)
if select_second:
cmds.select(select_second, add=True)
if isolate:
isolated_panel = cmds.paneLayout('viewPanes', q=True, pane1=True)
cmds.isolateSelect(isolated_panel, state=True)
cmds.isolateSelect(isolated_panel, aso=True)
def setUp(self):
self.targetMesh = 'testMesh'
self.numVerts = 169 # number of verts in our mesh
self.mll = MllInterface()
unittest.TestCase.setUp(self)
openMayaFile('simplemirror.ma')
cmds.hide("|y_axis")
cmds.showHidden("|x_axis")
self.mll.setCurrentMesh(self.targetMesh)
self.mll.initLayers()
self.mll.createLayer("original weights")
self.model = ie.LayerData()
self.layer = ie.Layer()
self.layer.opacity = 1.0
self.layer.enabled = True
self.layer.mask = [0.0] * self.numVerts
self.layer.mask[1] = 0.9
self.layer.mask[5] = 0.5566
self.layer.name = "imported layer"
self.model.addLayer(self.layer)
self.infl = ie.Influence()
self.layer.addInfluence(self.infl)
self.infl.influenceName = "x_axis|root|R_joint1"
self.infl.logicalIndex = 666 # use nonsense value
self.infl.weights = [0.1] * self.numVerts
self.infl.weights[3] = 0.688
self.infl.weights[4] = 0.345
def setUp(self):
self.targetMesh = 'testMesh'
self.numVerts = 169 # number of verts in our mesh
self.mll = MllInterface()
unittest.TestCase.setUp(self)
openMayaFile('simplemirror.ma')
cmds.hide("|y_axis")
cmds.showHidden("|x_axis")
self.mll.setCurrentMesh(self.targetMesh)
self.mll.initLayers()
self.mll.createLayer("original weights")
self.model = ie.LayerData()
self.layer = ie.Layer()
self.layer.opacity = 1.0
self.layer.enabled = True
self.layer.mask = [0.0]*self.numVerts
self.layer.mask[1] = 0.9
self.layer.mask[5] = 0.5566
self.layer.name = "imported layer"
self.model.addLayer(self.layer)
self.infl = ie.Influence()
self.layer.addInfluence(self.infl)
self.infl.influenceName = "x_axis|root|R_joint1"
self.infl.logicalIndex = 666 # use nonsense value
self.infl.weights = [0.1]*self.numVerts
self.infl.weights[3] = 0.688
self.infl.weights[4] = 0.345
def main(nodes):
"""docstring for main"""
for node in nodes:
if cmds.getAttr('{}.visibility'.format(node)):
cmds.hide(node)
else:
cmds.showHidden(node)
def exportAlembicData( prefix, exportTargets, startFrame, endFrame, step, path ):
import sgBFunction_base
sgBFunction_base.autoLoadPlugin( 'AbcExport' )
sgBFunction_base.autoLoadPlugin( 'AbcImport' )
if prefix:
prefix += '_'
topTransforms = []
visValues = []
for tr in cmds.ls( tr=1 ):
if cmds.listRelatives( tr, p=1 ): continue
topTransforms.append( tr )
visValues.append( cmds.getAttr( tr+'.v' ) )
cmds.setAttr( tr+'.v', 0 )
sgBFunction_fileAndPath.makeFolder( path )
for target in exportTargets:
target = cmds.ls( target, l=1 )[0]
cmds.showHidden( target, a=1 )
targetName = target.split( '|' )[-1]
filePath = path + '/' + prefix + targetName.replace( ':', '_' ) + '_s' + str( step ).replace( '.', '_' ) + '.abc'
cmds.AbcExport( target, j="-frameRange %s %s -step %s -writeVisibility -uvWrite -dataFormat ogawa -root %s -file %s" %( startFrame, endFrame, step, target, filePath ) )
for tr in topTransforms:
cmds.setAttr( tr+'.v', 0 )
for i in range( len( topTransforms ) ):
cmds.setAttr( topTransforms[i] + '.v', visValues[i] )
def makeInstance(name, instanceName, hiddenFlag):
"""
Create an instance of name that will be called instanceName.
hiddenFlag: If True, run a cmds.showHidden() command after duplication.
"""
cmds.duplicate(name, name=instanceName)
if hiddenFlag:
cmds.showHidden()
def finalise_render(self):
# unhide geo, reposition camera
if self.render_geo:
cmds.showHidden(self.render_geo)
cmds.setAttr("%s.xformMatrix" % self.render_camera,
self.render_camera_xforms,
type="matrix")
def toggle_hide_target(self, e=False):
if not self.target_name:
return
self._is_hidden = not self._is_hidden
if self._is_hidden:
cmds.hide(self.imported_nodes)
else:
cmds.showHidden(self.imported_nodes)
def hideLookdevScene(*arg):
if cmds.objExists(grpName):
testVis = cmds.getAttr(grpName + '.visibility')
if testVis == True:
cmds.hide(grpName)
else:
cmds.showHidden(grpName)
else:
pass
def __init__(self, position, rotation):
cmds.instance(self.template, n="outer_wall_" + str(self.index))
cmds.showHidden("outer_wall_" + str(self.index))
cmds.move(position.x, position.y + self.wallSize.y / 2, position.z,
"outer_wall_" + str(self.index))
cmds.rotate(rotation.x, rotation.y, rotation.z,
"outer_wall_" + str(self.index))
super(OuterWall, self).__init__("outer_wall_" + str(self.index))
self.IncementWallIndex()
def render(self):
""" Starts the render """
try: # If MtoA was not found
defaultTranslator = cmds.getAttr("defaultArnoldDisplayDriver.aiTranslator")
except ValueError:
cmds.warning("Current renderer is not set to Arnold.")
return
cmds.setAttr("defaultArnoldDisplayDriver.aiTranslator", "aton", type="string")
# Updating the port from UI
if self.defaultPort != 0:
port = self.portSpinBox.value()
cmds.setAttr("defaultArnoldDisplayDriver.port", port)
else:
cmds.warning("Current renderer is not set to Arnold or Aton driver is not loaded.")
return
# Adding time changed callback
if self.timeChangedCB == None:
self.timeChangedCB = OM.MEventMessage.addEventCallback("timeChanged", self.timeChnaged)
# Adding selection changed callback
if self.selectionChangedCB == None:
self.selectionChangedCB = OM.MEventMessage.addEventCallback("SelectionChanged", self.selectionChanged)
try: # If render session is not started yet
cmds.arnoldIpr(mode="stop")
except RuntimeError:
pass
# Temporary makeing hidden cameras visible before scene export
hCams = [
x
for x in cmds.listCameras()
if not cmds.getAttr("%s.visibility" % x)
or not cmds.getAttr("%s.visibility" % cmds.listRelatives(x, s=1)[0])
]
for i in hCams:
cmds.showHidden(i)
try: # Start IPR
camera = self.getCamera()
cmds.arnoldIpr(cam=camera, mode="start")
except RuntimeError:
cmds.warning("Current renderer is not set to Arnold.")
# Update IPR
self.IPRUpdate()
sys.stdout.write("// Info: Aton - Render started.\n")
# Setting back to default
for i in hCams:
cmds.hide(i)
cmds.setAttr("defaultArnoldDisplayDriver.aiTranslator", defaultTranslator, type="string")
cmds.setAttr("defaultArnoldDisplayDriver.port", self.defaultPort)
def hider(option, *args):
if option == 0:
mc.hide()
elif option == 1:
mc.select("*_ctrl*")
mc.hide()
elif option == 2:
mc.select("*_ctrl*")
mc.showHidden()
mc.select(clear=True)
def hide_model(self):
#self.ui2.hideModel_pushButton()
if self.hideM_button == 0:
for i in self.model:
mc.hide(self.model)
self.hideM_button = self.hideM_button + 1
else:
for i in self.model:
mc.showHidden(self.model)
self.hideM_button = 0
def create_render_cam_from_view(self):
cameraTransform = cmds.modelEditor(cmds.getPanel(withLabel='Persp View'),
query=True,
camera=True)
cameraShape = cmds.listRelatives(cameraTransform, type='camera')[0]
newCameraName = "render_cam"
cmds.duplicate(cameraShape, name=newCameraName)
cmds.showHidden(newCameraName)
cmds.select(newCameraName, replace=True)
def hide_modelDup(self):
#self.ui2.hideModel_pushButton()
if self.hideMD_button == 0:
for i in self.model_dup:
mc.hide(i)
self.hideMD_button = self.hideMD_button + 1
else:
for i in self.model_dup:
mc.showHidden(i)
self.hideMD_button = 0
def __init__(self, position):
cmds.instance(self.template, n="tower_" + str(self.index))
cmds.showHidden("tower_" + str(self.index))
cmds.move(position.x, position.y + self.height / 2, position.z,
"tower_" + str(self.index))
cmds.xform("tower_" + str(self.index), piv=(0, -self.height / 2, 0))
self.name = "tower_" + str(self.index)
self.IncementTowerIndex()
return
def renderAllLights(self, renderLights=[],useGroups=False):
lights = cmds.ls(dag=True,visible=True,lights=True, type='mentalrayIblShape')
#Check if there is any lights selected to only do those
if renderLights == [] or renderLights == None:
renderLights = cmds.ls( dag=True, sl=True , lights=True, type='mentalrayIblShape')
#if there isn't any light selected just get all the lights
if renderLights == []:
renderLights = lights
lightNames = ""
for light in renderLights:
lightNames = lightNames + light + '\n'
windowName = 'ProgressWindow'
if cmds.window(windowName, exists=True):
cmds.deleteUI(windowName)
window = cmds.window(windowName,t="Progress Report")
cmds.columnLayout()
cmds.iconTextStaticLabel( st='textOnly', l='Rendering Lights:' )
cmds.iconTextStaticLabel( st='textOnly', l=lightNames )
cmds.iconTextStaticLabel( st='textOnly', l='Process Bar' )
progressControl = cmds.progressBar(maxValue=len(renderLights), width=300)
cmds.showWindow( window )
lights = self.sortLightsByType(lights)
#-Revised--hide ibl node that is at the end of lights list (sorted previously)
if cmds.objectType( lights[-1], isType='mentalrayIblShape' ) == True:
cmds.setAttr('%s.visibleInFinalGather' % lights[-1], 0)
cmds.setAttr('%s.visibleInEnvironment' % lights[-1], 0)
cmds.hide(lights)
lightCount = 0
if useGroups==True:
renderLightsGroups = self.groupLightsByName(renderLights)
cmds.progressBar(progressControl,edit=True, maxValue=len(renderLightsGroups.keys()), width=300)
for group in renderLightsGroups:
self.renderOnlyThisLight(renderLightsGroups[group])
progressInc = cmds.progressBar(progressControl, edit=True, pr=lightCount+1)
lightCount+=1
else:
print renderLights
for light in renderLights:
self.renderOnlyThisLight(light)
progressInc = cmds.progressBar(progressControl, edit=True, pr=lightCount+1)
lightCount+=1
cmds.showHidden(lights)
#-Revised--since we sorted the lights by type we know that the lastone will be the IBL
if cmds.objectType( lights[-1], isType='mentalrayIblShape' ) == True:
cmds.setAttr('%s.visibleInFinalGather' % lights[-1], 1)
cmds.setAttr('%s.visibleInEnvironment' % lights[-1], 1)
def hyperRender():
gamma = mc.floatSliderGrp("gamma", q=True, v=True)
width = mc.intFieldGrp("Resolution", q=True, value1=True)
height = mc.intFieldGrp("Resolution", q=True, value2=True)
fr = mc.textFieldButtonGrp("setFile", q=True, text=True) + "/"
mc.eval
mc.select(lights)
mc.select(meshes, add=True)
mc.showHidden(a=True)
for m in meshes:
hideChildren(m)
for l in lights:
mc.hide(l)
for mesh in meshes:
# hideChildren(mesh)
for light in lights:
mc.select(cl=True)
mc.select(mesh)
mc.select(light, add=True)
showChildren(mesh)
mc.showHidden(light)
name = mesh + light + "output"
mc.setAttr("defaultArnoldDriver.ai_translator",
"png",
type="string")
mc.setAttr("defaultArnoldDriver.pre", name, type="string")
arnoldRender(width, height, True, True, 'RenderCam_',
' -layer defaultRenderLayer')
#render stuff here
editor = 'renderView'
#render_output = mc.renderer(editor, e=True)
# mc.eval('renderWindowRender redoPreviousRender renderView')
# editor = 'renderView'
formatManager = createImageFormats.ImageFormats()
formatManager.pushRenderGlobalsForDesc("PNG")
mc.renderWindowEditor(editor,
e=True,
ga=gamma,
com=True,
cme=True,
writeImage=fr + name + '.png')
exec("print 'file saved to' + fr+name+'.png'")
formatManager.popRenderGlobals()
mc.hide(light)
hideChildren(mesh)
def __init__(self, position, rotation):
cmds.instance(self.template, n="ground_wall_" + str(self.index))
cmds.showHidden("ground_wall_" + str(self.index))
#cmds.xform("ground_wall_" + str(self.index),piv=(0,-self.wallSize.y/2,0))
cmds.move(position.x, position.y, position.z,
"ground_wall_" + str(self.index))
cmds.rotate(rotation.x, rotation.y, rotation.z,
"ground_wall_" + str(self.index))
super(GroundWall, self).__init__("ground_wall_" + str(self.index))
self.IncementWallIndex()
return
def toggle_hide_source(self, e=False):
if not cmds.ls(self.source_name):
return
self._is_hidden = not self._is_hidden
if self._is_hidden:
cmds.hide(self.source_name)
else:
cmds.showHidden(self.source_name)
cmds.select(self.source_name)
def showHideObjects(self, *args):
'''
'''
if self._IScontextTool._mObjectsToHide:
if len(self._IScontextTool._mObjectsToHide) > 0:
bHide = cmds.checkBox(self._IShideObjectsCbx, query = True, value = True)
if bHide:
cmds.hide(self._IScontextTool._mObjectsToHide)
else:
cmds.showHidden(self._IScontextTool._mObjectsToHide)
def editSkin(self): if self.editSkin_button.isChecked() : self.mainPage_stackedWidget.setCurrentIndex(2) self.editCharacter_button.setChecked(False) self.editModules_button.setChecked(False) for m in modules: cmds.showHidden(m+":posers") cmds.hide(m+":controls") else: self.editSkin_button.setChecked(True)
def objectSel(self, item):
global objs
items = self.objectQList.selectedItems()
objs = []
for i in list(items):
objs.append(i.text())
self.statusBar.showMessage(str(objs), 4000)
cmds.showHidden(grpTemp + '*')
cmds.select(objs)
cmds.isolateSelect(viewer, s=False)
cmds.isolateSelect(viewer, s=True)
cmds.viewFit(objectViewerCam)
def solo_view(self, widget, solo):
instancer = node_utils.get_instancer(widget.name)
cmds.showHidden(instancer)
for geo_wdg, spore_wdgs in self.wdg_tree.iteritems():
for spore_wdg in spore_wdgs:
if spore_wdg is not widget:
spore_wdg.view_buttons.solo_btn.setChecked(False)
instancer = node_utils.get_instancer(spore_wdg.name)
if solo:
cmds.hide(instancer)
else:
cmds.showHidden(instancer)
def test_isVisible():
sel = cmdc.SelectionList().add("persp")
persp = sel.getDagPath(0)
assert not persp.isVisible()
cmds.showHidden("persp")
assert persp.isVisible()
invalid_dag = cmdc.DagPath()
nose.tools.assert_raises(
RuntimeError,
invalid_dag.isVisible,
)
def cancelPoseTarget(self):
'''Cancel pose target after initializing'''
if not self._poseTarget:
raise RuntimeError('Pose target should be initialized first')
(poseName, targetName, duplicate) = self._poseTarget
self._poseTarget = None
cmds.delete(duplicate)
defGeom = cmds.deformer(self.name, q=1, g=1)
cmds.showHidden(defGeom)
cmds.select(defGeom)
def vis_locators(self, show=False):
try:
if show:
self.checkbox.setChecked(True)
cmds.showHidden(cmds.listRelatives("GSnap", c=True))
return
if self.checkbox.isChecked():
cmds.showHidden(cmds.listRelatives("GSnap", c=True))
else:
cmds.hide(cmds.listRelatives("GSnap", c=True))
except:
pass
finally:
self.update_widgets()
def GetFrameMarker( self ): numMarkers = len( self.FrameMarkers ) marker = None self.NumFrameMarkersUsed += 1 if ( self.NumFrameMarkersUsed >= numMarkers ): gizmo = cmds.polySphere( radius = 1.0 )[ 0 ] marker = FrameMarker( gizmo ) self.FrameMarkers.append( marker ) else: marker = self.FrameMarkers[ self.NumFrameMarkersUsed - 1 ] cmds.showHidden( marker.GetGizmo() ) return marker
def editModules(self): if self.editModules_button.isChecked() : self.mainPage_stackedWidget.setCurrentIndex(1) self.editCharacter_button.setChecked(False) self.editSkin_button.setChecked(False) self.update_modules_list() for m in modules: cmds.showHidden(m+":posers") cmds.hide(m+":controls") #cmds.setAttr(m+":skinJoints.template", 1) else: self.editModules_button.setChecked(True)
def applyVisibility(self, lstObjects):
"""
Applies visibility only to the defined objects. This is a special
method that take cares of hierarchy problems.
"""
# Create two lists, one that will contain the full path to all objects
# that should be visible and another list containing all the objects
# that exists at the same level in the hierarchy (siblings)
lstVisible = []
lstNeighbours = []
lstSiblings = []
for sItem in lstObjects:
lstContent = mc.ls(sItem, transforms=True, long=True) or []
for sObjectFullPath in lstContent:
obj = self.reDirName.search(sObjectFullPath)
if obj:
sParentPath = obj.group()
lstSiblings = mc.listRelatives(sParentPath,
fullPath=True) or []
else:
sParentPath = ""
lstSiblings = mc.ls(assemblies=True, long=True)
lstNeighbours += lstSiblings
lstSiblings = []
lstVisible += lstContent
# Create a huge string containing all the objects that should be
# visibile
sAllHits = string.join(lstVisible, "\n")
# Iterate through all siblings and compare it with the huge string
# sAllHits. If a valid hit can be found within the string then make it
# visible, otherwise invisible
for sItem in lstNeighbours:
sRegExp = "^" + sItem.replace("|", "\\|")
if re.search(sRegExp, sAllHits, re.MULTILINE):
mc.showHidden([sItem], above=True)
else:
self.applyAttribute("visibility", False, [sItem])
def showViewer(self):
if self.objectViewCheckbox.isChecked():
self.objectViewer.setVisible(True)
winWidth = 800
self.resize(winWidth, winHeight)
if self.objectQList.currentItem():
cmds.showHidden(grpTemp + '*')
cmds.select(objs)
cmds.isolateSelect(viewer, s=False)
cmds.isolateSelect(viewer, s=True)
cmds.viewFit(objectViewerCam)
#cmds.refresh()
else:
self.hideViewer()
def applyVisibility(self, lstObjects):
"""
Applies visibility only to the defined objects. This is a special
method that take cares of hierarchy problems.
"""
# Create two lists, one that will contain the full path to all objects
# that should be visible and another list containing all the objects
# that exists at the same level in the hierarchy (siblings)
lstVisible = []
lstNeighbours = []
lstSiblings = []
for sItem in lstObjects:
lstContent = mc.ls(sItem, transforms = True, long = True) or []
for sObjectFullPath in lstContent:
obj = self.reDirName.search(sObjectFullPath)
if obj:
sParentPath = obj.group()
lstSiblings = mc.listRelatives(sParentPath, fullPath = True) or []
else:
sParentPath = ""
lstSiblings = mc.ls(assemblies = True, long = True)
lstNeighbours += lstSiblings
lstSiblings = []
lstVisible += lstContent
# Create a huge string containing all the objects that should be
# visibile
sAllHits = string.join(lstVisible, "\n")
# Iterate through all siblings and compare it with the huge string
# sAllHits. If a valid hit can be found within the string then make it
# visible, otherwise invisible
for sItem in lstNeighbours:
sRegExp = "^" + sItem.replace("|", "\\|")
if re.search(sRegExp, sAllHits, re.MULTILINE):
mc.showHidden([sItem], above = True)
else:
self.applyAttribute("visibility", False, [sItem])
def show_sel(self):
# get the item
obj = self.dictOfSceneObjects[self.indexed]
# Hide all
[cm.hide(x) for x in self.dictOfSceneObjects.values()]
cm.showHidden(obj)
cm.select(obj)
cm.showHidden(cm.listRelatives(obj, ap=1))
cm.viewFit('persp')
# get number of umv for selected item
self.umv = self.get_umvs()
# Select item again and print info
cm.select(obj)
self.print_sel_and_info()
def renderOnlyThisLight(self, lights):
if type(lights) != list:
lights = [lights]
lightNames = ''
for light in lights:
lightNames += '_' + cmds.listRelatives(light, p=1)[0]
wasHidden = False
if self.isLightHidden(light):
cmds.showHidden(light)
wasHidden = True
#-Revise!--if it is an ibl light then turn off emit Final Gather
if cmds.objectType(light, isType='mentalrayIblShape') == True:
if cmds.getAttr('%s.visibleInFinalGather' % light) == False:
cmds.setAttr('%s.visibleInFinalGather' % light, 1)
wasHidden = True
mel.eval("renderIntoNewWindow render")
#See if we are rendering with vray frame buffer and save it to the maya render buffer
if cmds.getAttr('defaultRenderGlobals.currentRenderer') == 'vray':
if self.isRenderEngineInstalled('vray'):
if cmds.getAttr("vraySettings.vfbOn"):
mel.eval("vrend -cloneVFB")
rv = cmds.getPanel(scriptType='renderWindowPanel')
caption = cmds.renderWindowEditor(rv, query=True, pca=True)
newCaption = caption + ' contriburion of ' + lightNames.replace(
'_', ' ')
cmds.renderWindowEditor(rv, edit=True, pca=newCaption)
# save the frame in mel
mel.eval("renderWindowMenuCommand keepImageInRenderView renderView;")
if self.saveImages:
self.saveCurrentImageInRenderView('contributionOf' + lightNames)
for light in lights:
if wasHidden:
cmds.hide(light)
#-Revise!-- if it was the ibl node disable final gather again
if cmds.objectType(light, isType='mentalrayIblShape') == True:
cmds.setAttr('%s.visibleInFinalGather' % light, 0)
def createThumbnail( mayafile , mode = 'nonExport' ):
if mode == 'export':
sel = cmds.ls(sl=1 , dag=True , type = 'mesh')
usel = cmds.ls(sl=False )
cmds.hide(usel)
for x in sel:
cmds.showHidden( x , above = True )
jpgfile = os.path.dirname( mayafile ) + os.sep + '.lib' + os.sep + '.'+ os.path.splitext( os.path.basename(mayafile) )[0] +'.jpg'
currFrame = int( cmds.currentTime( q = True ) )
# currFrame = int( (cmds.playbackOptions(q=1,min=1) + cmds.playbackOptions(q=1,max=1) ) / 2 )
format = cmds.getAttr("defaultRenderGlobals.imageFormat")
cmds.setAttr("defaultRenderGlobals.imageFormat", 8)
cmds.playblast(frame=currFrame, format="image", completeFilename=str( jpgfile ),
showOrnaments=False, viewer=False, widthHeight=[150, 100], percent=100 , os=1 )
cmds.setAttr( "defaultRenderGlobals.imageFormat", format )
# if mode == 'export' :
# cmds.showHidden( all = True )
return jpgfile
def renderOnlyThisLight(self, lights):
if type(lights)!=list:
lights = [lights]
lightNames =''
for light in lights:
lightNames += '_'+cmds.listRelatives(light, p=1)[0]
wasHidden = False
if self.isLightHidden(light) :
cmds.showHidden(light)
wasHidden = True
#-Revise!--if it is an ibl light then turn off emit Final Gather
if cmds.objectType( light, isType='mentalrayIblShape' ) == True:
if cmds.getAttr('%s.visibleInFinalGather' % light) == False:
cmds.setAttr('%s.visibleInFinalGather' % light, 1)
wasHidden = True
mel.eval("renderIntoNewWindow render")
#See if we are rendering with vray frame buffer and save it to the maya render buffer
if cmds.getAttr('defaultRenderGlobals.currentRenderer') == 'vray':
if self.isRenderEngineInstalled('vray'):
if cmds.getAttr ("vraySettings.vfbOn"):
mel.eval("vrend -cloneVFB")
rv = cmds.getPanel(scriptType='renderWindowPanel')
caption = cmds.renderWindowEditor(rv, query=True, pca=True)
newCaption = caption+' contriburion of '+lightNames.replace('_',' ')
cmds.renderWindowEditor(rv, edit=True, pca= newCaption)
# save the frame in mel
mel.eval("renderWindowMenuCommand keepImageInRenderView renderView;")
if self.saveImages:
self.saveCurrentImageInRenderView('contributionOf'+lightNames)
for light in lights:
if wasHidden:
cmds.hide(light)
#-Revise!-- if it was the ibl node disable final gather again
if cmds.objectType( light, isType='mentalrayIblShape' ) == True:
cmds.setAttr('%s.visibleInFinalGather' % light, 0)
def GetTranslationManip( self ): numManips = len( self.TranslationManips ) manip = None self.NumTranslationManipsUsed += 1 if ( self.NumTranslationManipsUsed >= numManips ): gizmo = cmds.polyCube( width = 2.5, height = 2.5, depth = 2.5 )[ 0 ] manip = Manip( gizmo ) self.TranslationManips.append( manip ) # ... scrip job para saber cuando se mueve ... manip.SetApp( self ) else: manip = self.TranslationManips[ self.NumTranslationManipsUsed - 1 ] cmds.showHidden( manip.GetGizmo() ) return manip
def _add_anim_lash1_ctrl(self, arg=None):
import baseFunctions_maya
reload (baseFunctions_maya)
getClass=baseFunctions_maya.BaseClass()
getLash=cmds.ls("Lash_*_1_LSH")
typeCtrl=""
size=.2
colour=22
for each in getLash:
getClass.sandwichControlFunct(colour, size, each,typeCtrl)
getLash=cmds.ls("Lash_*_1_LSH_Ctrl")
for item in getLash:
cmds.select(item)
cmds.showHidden(a=1)
getLash=cmds.ls("Lash_*_LSH")
for item in getLash:
cmds.setAttr(item+"Shape.visibility", 0)
getLash=cmds.ls("Lash_*_1_LSH_Ctrl")
for item in getLash:
cmds.connectAttr("*:EyeMask_Ctrl.showLashCtrls", item+".visibility", f=1)
def doPress(self):
# print "PRESS"
self.isMouseDown = True
am = self.activeManip()
m = Mom()
m.strandsSelected(
self.helicesNames,
(am is self.fDistanceFrontManip,
am is self.fDistanceBackManip)
)
self.createHelixDragMarker()
selectedItems = cmds.ls(Mom().helixTransformName + "*", selection=True)
bbox = cmds.exactWorldBoundingBox(selectedItems)
cmds.setAttr(
helixManip.transformName + ".scale",
bbox[3] - bbox[0],
0,
bbox[4] - bbox[1],
type="double3")
z = 0
if am is self.fDistanceFrontManip:
z = bbox[5]
elif am is self.fDistanceBackManip:
z = bbox[2]
self.moveHelixDragMarkerTo((
(bbox[0] + bbox[3]) / 2,
(bbox[1] + bbox[4]) / 2,
z
))
cmds.showHidden(helixManip.transformName)
self.calculateDeltaBounds()
return OpenMaya.kUnknownParameter
def toggleMaskActive(self, mode):
try:
cmds.undoInfo(openChunk=True)
if mode:
cmds.showHidden(self.controls)
cmds.showHidden(self.maskGeo)
#hide all movers
cmds.hide(self.faceModule.jointMovers)
#TODO: Need to check if the constraints were deleted and re-add them
'''for mover in self.faceModule.jointMovers:
sdk = cmds.listConnections(mover + '.sdk')[0]
sdkParent = cmds.listRelatives(sdk, parent = True)[0]
lra = cmds.listConnections(mover + '.lra')[0]
cmds.parentConstraint(lra, sdkParent)'''
print 'MASK: ACTIVATED'
else:
#show joint movers
cmds.showHidden(self.faceModule.jointMovers)
#hide the mask controls and mesh
cmds.hide(self.controls)
cmds.hide(self.maskGeo)
print 'MASK: DEACTIVATED'
except Exception as e:
print(traceback.format_exc())
finally:
cmds.undoInfo(closeChunk=True)
def finalizeCtx(self):
'''
called when we exit the context
'''
if cmds.objExists(self._mVoroImpactTrs):
cmds.delete(self._mVoroImpactTrs) ; self._mVoroImpactTrs = None
if cmds.objExists(self._mVoroDisplay[0]):
cmds.delete(self._mVoroDisplay) ; self._mVoroDisplay = None
if cmds.objExists(self._mVoroObject):
cmds.setAttr(self._mVoroObject + '.visibility', True)
mBreakNode = cmds.listConnections(self._mVoroObject, sh = True, type = 'fxBreakGeometry')
if len(mBreakNode) > 0:
if self._mVoroPoints.length() > 0:
cmds.setAttr(mBreakNode[0] + '.numPoints', self._mVoroPoints.length())
if len(self._mObjectsToHide):
cmds.showHidden(self._mObjectsToHide)
self._mVoroPoints.clear() ; self._mVoroPoints = None
self._mObjectsToHide = None
cmds.select(clear = True)
mel.eval('hyperShadePanelMenuCommand("hyperShadePanel1", "deleteUnusedNodes")')
cmds.scriptEditorInfo (clearHistory = True)
if self._mInViewMessage:
cmds.inViewMessage(amg = '<hl> IShatter Completed </hl>', dragKill = True, fade = True, pos = 'topCenter')
else:
cmds.headsUpMessage('IShatter Completed', verticalOffset = (cmds.control('modelPanel4', q = True, h = True) / 2.5))
cmds.scriptJob(event = ("idle", self.deleteIShatterCtx), runOnce = True)
#****************************************************************************************************************************************************************************************#
#****************************************************************************************************************************************************************************************#
# CLASS END DEFINITION #
#****************************************************************************************************************************************************************************************#
#****************************************************************************************************************************************************************************************#
def nextFn(self):
index = self.stackedWidget.currentIndex()+1
self.stackedWidget.setCurrentIndex(index)
if index > 0:
#disable / hide mask
if self.currentMask.active:
self.currentMask.active = False
self.backBTN.setHidden(False)
if index == 2:
self.snapVis(hide=False)
if index == 3:
self.snapVis(hide=True)
self.closeBTN.setHidden(False)
self.nextBTN.setHidden(True)
self.backBTN.setHidden(True)
#show sdks
if index != 1:
cmds.showHidden(self.currentFace.sdks)
cmds.hide(self.currentMask.maskGeo)
cmds.hide(self.currentMask.controls)
else:
cmds.hide(self.currentFace.sdks)
def backFn(self):
index = self.stackedWidget.currentIndex()-1
self.stackedWidget.setCurrentIndex(index)
if index == 0:
self.backBTN.setHidden(True)
self.currentMask.active = True
#show joint movers and sdks
cmds.showHidden(self.currentFace.jointMovers)
cmds.showHidden(self.currentFace.sdks)
if index != 2:
self.snapVis(hide=True)
else:
self.snapVis(hide=False)
cmds.hide(self.currentMask.maskGeo)
cmds.hide(self.currentMask.controls)
#show sdks
if index != 1:
cmds.showHidden(self.currentFace.sdks)
else:
cmds.hide(self.currentFace.sdks)
self.nextBTN.setHidden(False)
self.closeBTN.setHidden(True)
def __init__(self, parent=getMayaWindow(), debug=0):
QtGui.QMainWindow.__init__(self, parent)
#facial folder
#facialDir = os.path.dirname(__file__)
### BUILD USER INTERFACE
##############################
#create/set a central widget
wid = QtGui.QWidget()
self.setCentralWidget(wid)
#setArt v2 stylesheet
utils.setArtV2StyleSheet(wid, imageDirectory='/art2images')
self.verticalLayout = QtGui.QVBoxLayout(wid)
self.verticalLayout.setSpacing(2)
#top face module picker
self.label = QtGui.QLabel(self)
self.label.setText("FacialNode:")
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.addWidget(self.label)
self.currentFacialNodeCMB = QtGui.QComboBox(self)
self.horizontalLayout.addWidget(self.currentFacialNodeCMB)
self.resize(530, 390)
self.verticalLayout.addLayout(self.horizontalLayout)
self.page1 = QtGui.QFrame()
self.page1.setMinimumSize(QtCore.QSize( 530, 380 ))
self.page1.setMaximumSize(QtCore.QSize( 530, 380 ))
self.page2 = QtGui.QFrame()
self.page2.setMinimumSize(QtCore.QSize( 530, 380 ))
self.page2.setMaximumSize(QtCore.QSize( 530, 380 ))
self.page3 = QtGui.QFrame()
self.page3.setMinimumSize(QtCore.QSize( 530, 380 ))
self.page3.setMaximumSize(QtCore.QSize( 530, 380 ))
self.page4 = QtGui.QFrame()
self.page4.setMinimumSize(QtCore.QSize( 530, 380 ))
self.page4.setMaximumSize(QtCore.QSize( 530, 380 ))
self.stackedWidget = QtGui.QStackedWidget()
self.stackedWidget.addWidget(self.page1)
self.stackedWidget.addWidget(self.page2)
self.stackedWidget.addWidget(self.page3)
self.stackedWidget.addWidget(self.page4)
self.verticalLayout.addWidget(self.stackedWidget)
#set the image backdrops
image = (os.path.dirname(__file__) + '\\process_splash_align_mask.png').replace('\\','/')
self.page1.setStyleSheet("background-image: url(" + image + ");")
image = (os.path.dirname(__file__) + '\\process_splash_align_eyes.png').replace('\\','/')
self.page2.setStyleSheet("background-image: url(" + image + ");")
image = (os.path.dirname(__file__) + '\\process_splash_snap.png').replace('\\','/')
self.page3.setStyleSheet("background-image: url(" + image + ");")
image = (os.path.dirname(__file__) + '\\process_splash_goodbye.png').replace('\\','/')
self.page4.setStyleSheet("background-image: url(" + image + ");")
#Add next button
self.nextBTN = QtGui.QPushButton(self)
self.nextBTN.setText('NEXT')
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
self.nextBTN.setFont(font)
self.nextBTN.setGeometry(420, 300, 90, 25)
#Add back button
self.backBTN = QtGui.QPushButton(self)
self.backBTN.setText('BACK')
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
self.backBTN.setFont(font)
self.backBTN.setGeometry(420, 330, 90, 25)
self.backBTN.setHidden(True)
self.stackedWidget.setCurrentIndex(0)
#build and hide the 'mesh chooser'
self.meshBTN = QtGui.QPushButton(self)
self.meshBTN.setText('<<')
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
self.meshBTN.setFont(font)
self.meshBTN.setGeometry(0, 0, 25, 25)
#build and hide the 'mesh chooser'
self.snapBTN = QtGui.QPushButton(self)
self.snapBTN.setText('SNAP')
font = QtGui.QFont()
font.setPointSize(12)
font.setBold(True)
self.snapBTN.setFont(font)
self.snapBTN.setGeometry(300, 330, 90, 25)
self.meshLBL = QtGui.QLabel(self)
self.meshLBL.setText("Facial Mesh:")
self.meshEdit = QtGui.QLineEdit(self)
self.hMeshLayout = QtGui.QHBoxLayout()
self.hMeshLayout.addWidget(self.meshLBL)
self.hMeshLayout.addWidget(self.meshEdit)
self.hMeshLayout.addWidget(self.meshBTN)
self.hMeshLayout.setGeometry(QtCore.QRect(100, 300, 300, 25))
#close button
self.closeBTN = QtGui.QPushButton(self)
self.closeBTN.setText('Thank you Masky,\nI will alsways remember you..')
font = QtGui.QFont()
font.setPointSize(16)
font.setBold(True)
self.closeBTN.setFont(font)
self.closeBTN.setGeometry(25, 250, 500, 70)
self.closeBTN.setHidden(True)
#button connects
self.nextBTN.clicked.connect(self.nextFn)
self.backBTN.clicked.connect(self.backFn)
self.meshBTN.clicked.connect(self.meshFn)
self.snapBTN.clicked.connect(self.snapFn)
self.closeBTN.clicked.connect(self.close)
self.snapVis(hide=True)
self.refreshUI()
#show joint movers and sdks
cmds.showHidden(self.currentFace.jointMovers)
cmds.showHidden(self.currentFace.sdks)
def unhideShapes(node):
for shape in cmds.listRelatives(node, shapes=1, f=1):
cmds.showHidden(shape)
def updates(self):
getClass.sandwichAuto("Chin_Ctrl", "_SDK", 22, 1)
getObject="Chin_SDK_Ctrl"
getChildShape=cmds.listRelatives(getObject, c=1, typ="shape")
cmds.setAttr(getChildShape[0]+".visibility", 0)
lognm=getObject.replace('_Ctrl', "")
cmds.rename(getObject, lognm)
#current requests and fixes to the rig
cmds.parent("head01_jnt", w=1)
cmds.delete("head01_grp_parentConstraint1")
cmds.orientConstraint("UpperBody_Ctrl", "head01_grp", mo=1)
trans, rot=getClass.locationXForm("head01_jnt")
cmds.joint(n="neck02_jnt", p=trans)
cmds.parent("neck02_jnt", "neck01_jnt")
cmds.pointConstraint("neck02_jnt", "head01_grp", mo=1)
cmds.parent("head01_jnt", "Rig")
getAllCtrl=cmds.ls("*_Ctrl")
for each in getAllCtrl:
try:
cmds.setAttr(each+".Stretch", 1)
except:
pass
cmds.setAttr("Hips_Ctrl.StretchSpine", 1)
footSides=("Left", "Right")
for each in footSides:
item="football"+each+"_jnt"
trans, rot=getClass.locationXForm(item)
cmds.parent(item, w=1)
cmds.select(cl=1)
jntName=item.split("_jnt")[0]+"RT_jnt"
getClass.rigJointnames(item, jntName)
cmds.parent(item, jntName)
cmds.parent(jntName, "footankle"+each+"_jnt")
if "Left" in each:
cmds.disconnectAttr("Footheel_IK_L_Ctrl.RaiseToe","footballLeft_jnt.rotateZ")
cmds.connectAttr("Footheel_IK_L_Ctrl.RaiseToe","footballLeftRT_jnt.rotateX", f=1)
if "Right" in each:
cmds.disconnectAttr("Footheel_IK_R_Ctrl.RaiseToe","footballRight_jnt.rotateZ")
cmds.connectAttr("Footheel_IK_R_Ctrl.RaiseToe","footballRightRT_jnt.rotateX", f=1)
hideObjects=("BottomLid_L_Ctrl", "BottomLid_R_Ctrl", "TopLid_R_Ctrl", "TopLid_L_Ctrl", "armshoulderLeftIK_jnt_edloc", "armshoulderLeftIK_jnt_bdloc", "armshoulderRightIK_jnt_bdloc", "armshoulderRightIK_jnt_edloc", "spineIK_crv", )
for each in hideObjects:
cmds.setAttr(each+".visibility", 0)
try:
cmds.setAttr("tailIK_crv.visibility", 0)
except:
pass
lockHideObjects=('armshoulderLeftIK_jnt_bdloc','armshoulderRightIK_jnt_bdloc','leghipLeftIK_jnt_bdloc','leghipRightIK_jnt_bdloc','armshoulderLeftIK_jnt_edloc','armshoulderRightIK_jnt_edloc','leghipLeftIK_jnt_edloc','leghipRightIK_jnt_edloc')
for each in lockHideObjects:
cmds.setAttr(each+".tx" , k=0, cb=0)
cmds.setAttr(each+".ty" , k=0, cb=0)
cmds.setAttr(each+".tz", k=0, cb=0)
cmds.setAttr(each+".rx" , k=0, cb=0)
cmds.setAttr(each+".ry" , k=0, cb=0)
cmds.setAttr(each+".rz", k=0, cb=0)
cmds.setAttr(each+".sx" , k=0, cb=0)
cmds.setAttr(each+".sy" , k=0, cb=0)
cmds.setAttr(each+".sz", k=0, cb=0)
cmds.showHidden("armwristRight_jnt_ikPole_lctr", a=1)
cmds.showHidden("armwristLeft_jnt_ikPole_lctr", a=1)
hideList=("Armwrist_IK_L_Ctrl", "Armwrist_IK_R_Ctrl")
for each in hideList:
try:
getShapes=[(each) for each in cmds.listRelatives(each, typ="shape") if "lctr" not in each]
for shape in getShapes:
cmds.setAttr(shape+".visibility", 0)
except:
pass
cmds.addAttr("Armhand_IK_R_Ctrl", ln="ExtraPoleControl", at="enum",en="off:on:", k=1, nn="ExtraPoleControl")
cmds.addAttr("Armhand_IK_L_Ctrl", ln="ExtraPoleControl", at="enum",en="off:on:", k=1, nn="ExtraPoleControl")
cmds.connectAttr("Armhand_IK_L_Ctrl.ExtraPoleControl", "armwristLeft_jnt_ikPole_lctr.visibility")
cmds.connectAttr("Armhand_IK_R_Ctrl.ExtraPoleControl", "armwristRight_jnt_ikPole_lctr.visibility")
cmds.setAttr("armwristRight_jnt_ikPole_lctr.ty", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.rx", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.ry", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.rz", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.sx", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.sy", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.sz", k=0, cb=0)
cmds.setAttr("armwristRight_jnt_ikPole_lctr.visibility", lock=1)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.ty", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.rx", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.ry", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.rz", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.sx", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.sy", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.sz", k=0, cb=0)
cmds.setAttr("armwristLeft_jnt_ikPole_lctr.visibility", lock=1)
#new arm IK layout
try:
cmds.delete("armwristLeft_offset_IK_ctrl_parentConstraint1")
except:
pass
try:
cmds.delete("armwristRight_offset_IK_ctrl_parentConstraint1")
except:
pass
cmds.parentConstraint("Armhand_IK_R_Ctrl", "armwristRight_offset_IK_grp", mo=1)
cmds.parentConstraint("Armhand_IK_L_Ctrl", "armwristLeft_offset_IK_grp", mo=1)
cmds.parent("armwristLeftIK_grp", "Armcollar_IK_L_Ctrl")
cmds.parent("armwristRightIK_grp", "Armcollar_IK_R_Ctrl")
cmds.delete("EyeMask_Offset_Ctrl_parentConstraint1")
cmds.parentConstraint("Head_Ctrl", "EyeMask_Offset_grp", mo=1)
transforms = cmds.ls(type='transform')
deleteList = []
for tran in transforms:
if cmds.nodeType(tran) == 'transform':
children = cmds.listRelatives(tran, c=True)
if children == None:
deleteList.append(tran)
cmds.delete(deleteList)
getSel=("armwristLeft_jnt_ikPole_lctr",
"armelbowLeft_jnt_ikPole_lctr",
"armelbowRight_jnt_ikPole_lctr",
"armwristRight_jnt_ikPole_lctr")
for each in getSel:
cmds.sets(each, include="BodyControllers")
lognm=each.replace("_lctr", '_Ctrl')
getnewname=lognm.replace("_jnt", "")
getcleanname=getnewname.replace("ikPole", "PoleVector")
getFullName=getcleanname.replace("arm", "")
#capitalString=getFullName.capitalize()
if "Right" in each:
getPartname=getFullName.replace("Right", "_R")
else:
getPartname=getFullName.replace("Left", "_L")
print getPartname
cmds.rename(each, getPartname)
thumbGrp=cmds.ls("*thumb*_guide")
cmds.delete(thumbGrp)
Sides=["_L_", "_R_"]
fullSides=["Left", "Right"]
for eachside, eachFullside in map(None, Sides, fullSides):
cmds.parent("armhand"+eachFullside+"IK_grp", w=1)
cmds.parentConstraint("Armcollar_IK"+eachside+"Ctrl", "armhand"+eachFullside+"IK_grp", mo=1)
cmds.parentConstraint("Main_Ctrl", "armhand"+eachFullside+"IK_grp", mo=1)
#cmds.addAttr("Armhand_IK"+eachside+"Ctrl", ln="ArmFollow", min=0, max=1, at="double", k=1, nn="ArmFollow")
cmds.addAttr("Armhand_IK"+eachside+"Ctrl", ln="ArmFollow", at="enum", en="on:World:Main:", k=1, nn="ArmFollow")
cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 0)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", 1)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Main_CtrlW1", 0)
cmds.setDrivenKeyframe("armhand"+eachFullside+"IK_grp_parentConstraint1", cd="Armhand_IK"+eachside+"Ctrl.ArmFollow")
cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 1)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", 0)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Main_CtrlW1", 0)
cmds.setDrivenKeyframe("armhand"+eachFullside+"IK_grp_parentConstraint1", cd="Armhand_IK"+eachside+"Ctrl.ArmFollow")
cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 2)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", 0)
cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Main_CtrlW1", 1)
cmds.setDrivenKeyframe("armhand"+eachFullside+"IK_grp_parentConstraint1", cd="Armhand_IK"+eachside+"Ctrl.ArmFollow")
cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 0)
cmds.parent("armhandLeftIK_grp","Rig")
cmds.parent("armhandRightIK_grp","Rig")
cmds.addAttr("Main_Ctrl", ln="WaistFollow", min=0, max=1, at="double", k=1, nn="WaistFollow")
cmds.connectAttr("Main_Ctrl.WaistFollow","WaistFollow_CtrlShape.visibility")
cmds.connectAttr("Main_Ctrl.WaistFollow","WaistFollow_offset_CtrlShape.visibility")
# Sides=["_L_", "_R_"]
# fullSides=["Left", "Right"]
# for eachside, eachFullside in map(None, Sides, fullSides):
# cmds.parent("armhand"+eachFullside+"IK_grp", w=1)
# cmds.parentConstraint("Armcollar_IK"+eachside+"Ctrl", "armhand"+eachFullside+"IK_grp", mo=1)
# cmds.addAttr("Armhand_IK"+eachside+"Ctrl", ln="ArmFollow", min=0, max=1, at="double", k=1, nn="ArmFollow")
# cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 1)
# cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", 1)
# cmds.setDrivenKeyframe("armhand"+eachFullside+"IK_grp_parentConstraint1", cd="Armhand_IK"+eachside+"Ctrl.ArmFollow")
# cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 0)
# cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", 0)
# cmds.setDrivenKeyframe("armhand"+eachFullside+"IK_grp_parentConstraint1", cd="Armhand_IK"+eachside+"Ctrl.ArmFollow")
# cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 1)
# cmds.setAttr("armhand"+eachFullside+"IK_grp_parentConstraint1.Armcollar_IK"+eachside+"CtrlW0", lock=1)
# cmds.setAttr("Armwrist_offset_IK"+eachside+"CtrlShape.visibility", 0)
#
# cmds.setAttr("Armhand_IK"+eachside+"Ctrl.ArmFollow", 2)
#
#
# cmds.addAttr("EyeMask_Ctrl", ln="HeadFollow", min=0, max=1, at="double", k=1, nn="HeadFollow")
# cmds.setAttr("EyeMask_Ctrl.HeadFollow", 1)
# cmds.setAttr("EyeMask_Offset_grp_parentConstraint1.Head_CtrlW0", 1)
# cmds.setDrivenKeyframe("EyeMask_Offset_grp_parentConstraint1", cd="EyeMask_Ctrl.HeadFollow")
# cmds.setAttr("EyeMask_Ctrl.HeadFollow", 0)
# cmds.setAttr("EyeMask_Offset_grp_parentConstraint1.Head_CtrlW0", 0)
# cmds.setDrivenKeyframe("EyeMask_Offset_grp_parentConstraint1", cd="EyeMask_Ctrl.HeadFollow")
# cmds.setAttr("EyeMask_Ctrl.HeadFollow", 1)
# cmds.setAttr("EyeMask_Offset_grp_parentConstraint1.Head_CtrlW0", lock=1)
Side=["R", "L"]
for eachSide in Side:
startEyeJoint=["Eye_"+eachSide+"_jnt"]
IKEyelist=["EyeOrient_"+eachSide+"_jnt"]
for each, item in map(None, IKEyelist, startEyeJoint):
try:
cmds.delete("Eye_"+eachSide+"_jnt_aimConstraint1")
cmds.ikHandle(n=each+"_ik", sj=item, ee=each, sol="ikRPsolver")
cmds.setAttr(each+"_ik.visibility", 0)
cmds.parent(each+"_ik", "EyeOrient_"+eachSide+"_Ctrl")
except:
pass
Side=["Right", "Left"]
for eachSide in Side:
getLimb=["legknee"+eachSide]
IKHandlesLimbsarms=["armelbow"+eachSide,
"armwrist"+eachSide]
for each in IKHandlesLimbsarms:
getTranslation=cmds.xform(each+"_jnt", q=1, t=1, ws=1)
name=each+"FK_target"
grpname=each+"FK_target"+"_grp"
print grpname
num=3
color=22
if "elbow" in each:
getClass.JackI(name, grpname, num, getTranslation, (0.0,0.0,0.0), color)
cmds.move( 0.0, 0.0, -10.0,grpname,r=1, rpr=1)
cmds.parent(grpname,each+"FK_jnt")
cmds.setAttr(name+".visibility", 0)
cmds.makeIdentity(name, a=True, t=1, s=1, r=1, n=0)
if "wrist" in each:
getClass.JackI(name, grpname, num, getTranslation, (0.0,0.0,0.0), color)
cmds.move(0.0, -5.0, 0.0,grpname,r=1, rpr=1)
cmds.parent(grpname,each+"FK_jnt")
cmds.setAttr(name+".visibility", 0)
cmds.makeIdentity(name, a=True, t=1, s=1, r=1, n=0)
for each in getLimb:
getTranslation=cmds.xform(each+"_jnt", q=1, t=1, ws=1)
name=each+"FK_target"
grpname=each+"FK_target"+"_grp"
print grpname
num=3
color=22
getTranslation=cmds.xform(each+"_jnt", q=1, t=1, ws=1)
if "knee" in each:
getClass.JackI(name, grpname, num, getTranslation, (0.0,0.0,0.0), color)
cmds.move( 0.0, 0.0, +30.0,grpname,r=1, rpr=1)
cmds.parent(grpname,each+"FK_jnt")
cmds.setAttr(name+".visibility", 0)
cmds.makeIdentity(name, a=True, t=1, s=1, r=1, n=0)
try:
cmds.addAttr("EyeMask_Ctrl", ln="CheekLeftUp", min=0, max=1, at="double", k=1, nn="CheekLeftUp")
cmds.addAttr("EyeMask_Ctrl", ln="CheekRightUp", min=0, max=1, at="double", k=1, nn="CheekRightUp")
except:
pass
cmds.setAttr("Hips_Ctrl.spineFK_IK", 0)
selObj=cmds.ls("*Elbow_*_Ctrl")
for each in selObj:
cmds.setAttr(each+".rx", cb=1)
cmds.setAttr(each+".rx", k=1)
cmds.setAttr(each+".rx", l=0)
cmds.setAttr(each+".rotateOrder", 3)
selObj=cmds.ls("Hand_*_Fingers_Ctrl")
for each in selObj:
cmds.addAttr(each+".SpreadFingers", e=1, min=-0, max=90)
cmds.addAttr(each+".CurlFingers", e=1, min=-160, max=0)
selObj=cmds.ls("*_Finger_*_Ctrl")
for each in selObj:
if "|" not in each:
cmds.addAttr(each+".MiddleJoint", e=1, min=-160, max=0)
cmds.addAttr(each+".LastJoint", e=1, min=-160, max=0)
cmds.addAttr(each+".FingerFullCurl", e=1, min=-160, max=0)
getSel=cmds.ls("leghip*IK_jnt_*loc")
for item in getSel:
for each in trans:
cmds.setAttr(item+each, k=0)
cmds.setAttr(item+".visibility", 0)
import maya.cmds as cmds
sels = cmds.ls( sl=1 )
selChildren = cmds.listRelatives( sels, c=1, ad=1, type='shape', f=1 )
children = []
for child in selChildren:
childP = cmds.listRelatives( child, p=1, f=1 )[0]
if cmds.nodeType( child ) == 'gpuCache':
cmds.showHidden( childP, a=1 )
else:
try:cmds.setAttr( childP + '.v', 0 )
except:pass
cmds.select( children )
def render(self):
''' Starts the render '''
try: # If MtoA was not found
defaultTranslator = cmds.getAttr("defaultArnoldDisplayDriver.aiTranslator")
except ValueError:
cmds.warning("Current renderer is not set to Arnold.")
return
cmds.setAttr("defaultArnoldDisplayDriver.aiTranslator", "aton", type="string")
# Updating extraHost and port from UI
if self.defaultPort != 0:
extraHost = self.extraHostLineEdit.text()
port = self.portSpinBox.value()
cmds.setAttr("defaultArnoldDisplayDriver.extraHost", extraHost, type="string")
cmds.setAttr("defaultArnoldDisplayDriver.port", port)
else:
cmds.warning("Current renderer is not set to Arnold or Aton driver is not loaded.")
return
# Adding time changed callback
if self.timeChangedCB == None:
self.timeChangedCB = OM.MEventMessage.addEventCallback("timeChanged", self.timeChnaged)
# Adding selection changed callback
if self.selectionChangedCB == None:
self.selectionChangedCB = OM.MEventMessage.addEventCallback('SelectionChanged', self.selectionChanged)
try: # If render session is not started yet
cmds.arnoldIpr(mode='stop')
except RuntimeError:
pass
# Temporary makeing hidden cameras visible before scene export
hCams = []
for i in cmds.listCameras():
if not cmds.getAttr(i + ".visibility"):
hCams.append(i)
sl = cmds.listRelatives(i, s=1)
if sl and not cmds.getAttr(sl[0] + ".visibility"):
hCams.append(sl[0])
for i in hCams: cmds.showHidden(i)
# Set Progressive refinement to off
if self.sequence_enabled:
cmds.setAttr("defaultArnoldRenderOptions.progressive_rendering", False)
try: # Start IPR
cmds.arnoldIpr(cam=self.getCamera(), mode='start')
sys.stdout.write("// Info: Aton - Render started.\n")
except RuntimeError:
cmds.warning("Current renderer is not set to Arnold.")
# Sequence Rendering
if self.sequence_enabled:
self.frame_sequence.start()
# Update IPR
self.IPRUpdate()
# Setting back to default
for i in hCams: cmds.hide(i)
cmds.setAttr("defaultArnoldDisplayDriver.aiTranslator", defaultTranslator, type="string")
cmds.setAttr("defaultArnoldDisplayDriver.port", self.defaultPort)
def exportCharacter( setGroup, exportPath=None ):
import cPickle
import sgBFunction_fileAndPath
import sgBFunction_dag
topTransforms = sgBFunction_dag.getTopTransformNodes()
hidedObjs = []
for topTransform in topTransforms:
if cmds.getAttr( topTransform + '.v' ):
try:
cmds.setAttr( topTransform + '.v', 0 )
hidedObjs.append( topTransform )
except:pass
cmds.showHidden( setGroup, a=1 )
sceneName = cmds.file( q=1, sceneName=1 )
sceneFolderName = '/'.join( sceneName.split( '/' )[:-1] )
ns = setGroup.replace( 'SET', '' )
if not exportPath:
fileName = sceneFolderName + '/' + ns.replace( ':', '_' ) +'.txt'
print fileName
else:
fileName = exportPath
children = sgBFunction_dag.getChildrenCurveExists( setGroup )
targetCtls = []
for child in children:
childName = child.split( '|' )[-1]
if childName.lower().find( 'ctl' ) == -1: continue
refConExists = False
attrs = cmds.listAttr( child, k=1 )
srcCons = []
for attr in attrs:
cons = cmds.listConnections( child + '.' + attr, s=1, d=0 )
if not cons: cons = []
parentAttrs = cmds.attributeQuery( attr, node=child, listParent=1 )
if parentAttrs:
consParent = cmds.listConnections( child + '.' + parentAttrs[0], s=1, d=0 )
if consParent: cons += consParent
if not cons: continue
for con in cons:
conNode = con.split( '.' )[0]
if cmds.referenceQuery( conNode, inr=1 ): continue
srcCons.append( con )
for srcCon in srcCons:
if cmds.referenceQuery( srcCon, inr=1 ):
refConExists=True
break
if refConExists: continue
attrs = cmds.listAttr( child, k=1 )
targetCtls.append( [childName.replace( ns, '' ), attrs] )
minFrame= int( cmds.playbackOptions( q=1, min=1 ) )
maxFrame= int( cmds.playbackOptions( q=1, max=1 ) )
framesCtlsValues = []
for i in range( minFrame, maxFrame+1 ):
cmds.currentTime( i )
ctlsValues = []
for targetCtl, attrs in targetCtls:
targetCtl = ns + targetCtl
ctlValues = []
for attr in attrs:
value = cmds.getAttr( targetCtl + '.' + attr )
ctlValues.append( value )
ctlsValues.append( ctlValues )
framesCtlsValues.append( ctlsValues )
for hideObj in hidedObjs:
cmds.setAttr( hideObj + '.v', 1 )
data = ( minFrame, maxFrame, targetCtls, framesCtlsValues )
print "fileName : ", fileName
f = open( fileName, 'w' )
cPickle.dump( data, f )
f.close()
mayaDoc = sgBFunction_fileAndPath.getMayaDocPath()
defaultBakePath = mayaDoc + '/defaultCharacterBakePath.txt'
f = open( defaultBakePath, 'w' )
f.write( fileName )
f.close()
def finalise_render(self):
# unhide geo, reposition camera
if self.render_geo:
cmds.showHidden(self.render_geo)
cmds.setAttr("%s.xformMatrix" % self.render_camera, self.render_camera_xforms, type="matrix")
def updateSelectionBoxes(self):
selectedItems = cmds.ls(self.helixTransformName + "*", selection=True)
if selectedItems:
bbox = cmds.exactWorldBoundingBox(selectedItems)
cmds.setAttr(
self.selectionBox + ".scale",
bbox[3] - bbox[0],
bbox[4] - bbox[1],
bbox[5] - bbox[2],
type="double3")
cmds.setAttr(
self.selectionBox + ".translate",
(bbox[0] + bbox[3]) / 2,
(bbox[1] + bbox[4]) / 2,
(bbox[2] + bbox[5]) / 2,
type="double3")
cmds.showHidden(self.selectionBox)
selectionDict = app().activeDocument.document().selectionDict()
frontEp = 0
backEp = 0
for strandSetDict in selectionDict.itervalues():
for strand, value in strandSetDict.iteritems():
frontEp += int(value[0])
backEp += int(value[1])
if (frontEp == 0) ^ (backEp == 0):
epBoundBox = None
for strandSetDict in selectionDict.itervalues():
for strand, value in strandSetDict.iteritems():
# XXX The following line is a work around for broken
# path selection in model, remove when fixed
if not strand in self.cnToMaya:
continue
helixNode = self.cnToMaya[strand]
boundBox = cmds.exactWorldBoundingBox(helixNode[1])
# might be better to get the rise this way...
#n = OpenMaya.MFnDependencyNode(helixNode)
#risePlug = n.findPlug("rise")
#rise = risePlug.asDouble()
# but this works too
idxL, idxH = strand.idxs()
rise = (boundBox[5] - boundBox[2]) / (idxH - idxL + 1)
if frontEp == 0:
boundBox[5] = boundBox[2] + rise
elif backEp == 0:
boundBox[2] = boundBox[5] - rise
if epBoundBox == None:
epBoundBox = boundBox
else:
# union the boxes
epBoundBox[0] = min(epBoundBox[0], boundBox[0])
epBoundBox[1] = min(epBoundBox[1], boundBox[1])
epBoundBox[2] = min(epBoundBox[2], boundBox[2])
epBoundBox[3] = max(epBoundBox[3], boundBox[3])
epBoundBox[4] = max(epBoundBox[4], boundBox[4])
epBoundBox[5] = max(epBoundBox[5], boundBox[5])
# XXX The following line is a work around for broken
# path selection in model, remove when fixed
if not epBoundBox == None:
cmds.showHidden(self.epSelectionBox)
cmds.setAttr(
self.epSelectionBox + ".scale",
epBoundBox[3] - epBoundBox[0],
epBoundBox[4] - epBoundBox[1],
epBoundBox[5] - epBoundBox[2],
type="double3")
cmds.setAttr(
self.epSelectionBox + ".translate",
(epBoundBox[0] + epBoundBox[3]) / 2,
(epBoundBox[1] + epBoundBox[4]) / 2,
(epBoundBox[2] + epBoundBox[5]) / 2,
type="double3")
else:
cmds.hide(self.epSelectionBox)
else:
cmds.hide(self.selectionBox)
cmds.hide(self.epSelectionBox)
def pixelizer():
#grab object name
objname = cmds.ls(sl=True).pop()
#initial cube to be instanced
cmds.polyCube(n='pixelcube')
cmds.hide('pixelcube')
#reselect the object to be pixelized
cmds.select(objname)
#selects all vertices
cmds.ConvertSelectionToVertices()
listofvertices = cmds.ls(selection=True)
#this grabs the string that will be parsed to get the max number of vertices of the geo selected
lestring = listofvertices.pop()
#find the index of the last ':' and the index of the last ']' and grab the string in between these indices to get the max vertex number
#ex: pCube1.vtx[0:7]
begin = lestring.rfind(':')+1
end = lestring.index(']')
totalvertices = int(lestring[begin:end]) + 1
print totalvertices
#create a dictionary that stores 3-slot arrays that tell position of a vertex already drawn
drawnvtxdict = {}
#store number of boxes drawn
boxnum = 0
#for loop through number of vertices
for vtxnum in range(0, totalvertices):
#gets string to select specified vertex
nextvtx = objname + '.vtx[' + str(vtxnum) + ']'
cmds.select(nextvtx)
#to get value of position (a 3 slot array), make the new instanced cubename, then create an array of the int values
pos = cmds.xform(ws=True, q=True, t=True)
x1 = str(int(pos[0]))
y1 = str(int(pos[1]))
z1 = str(int(pos[2]))
intposstr = x1+','+y1+','+z1
#check if dictionary empty!!!!!!
if (drawnvtxdict.__len__() == 0):
newcubename = 'pixelcube' + str(boxnum)
cmds.select('pixelcube')
cmds.instance(n=newcubename)
cmds.xform(t=(int(pos[0]), int(pos[1]), int(pos[2])))
cmds.showHidden(newcubename)
drawnvtxdict[intposstr] = True
boxnum+=1
else:
if (not intposstr in drawnvtxdict.keys()):
newcubename = 'pixelcube' + str(boxnum)
cmds.select('pixelcube')
cmds.instance(n=newcubename)
cmds.xform(t=(int(pos[0]), int(pos[1]), int(pos[2])))
cmds.showHidden(newcubename)
drawnvtxdict[intposstr] = True
boxnum += 1
print str(boxnum) + ' boxes drawn : ' + str(vtxnum+1) + ' of ' + str(totalvertices) + ' done'
#selects all newly created blocks
cmds.select('pixelcube*')
#groups them together
cmds.group(n='pixelated_obj')
cmds.hide(objname)
def batch_render():
del_pointcloud()
#autoload Mental-Ray, from http://forums.cgsociety.org/archive/index.php/t-1001360.html
#cmds.loadPlugin('Mayatomr', quiet=True)
#cmds.setAttr('defaultRenderGlobals.ren', 'mentalRay', type='string')
cmds.undoInfo(state=False)
#imageFormat 32 means PNG, from here: http://www.oputo.com/html/blog/2010/06/12/defaultrenderglobals-imageformat/
cmds.setAttr('defaultRenderGlobals.imageFormat', 32)
#hide our TEMPLATE
cmds.hide( "template_skin" )
cmds.hide( "template_bone" )
input_bones_list = cmds.getFileList(folder=path_of_files, filespec='bone*.obj')
frames_rendered = 0
for curr_bone in input_bones_list:
#take off the .obj, then get the last four digits of the name of the file
#split_name = curr_bone.split('.')
#file_name = split_name[0]
#curr_digits = file_name[-4:]
#print curr_digits
curr_digits, bone_name, frm_name = get_bone_digit(curr_bone)
# Assign shader to objects
if draw_mesh:
cmds.file(path_of_files + bone_name, i=True)
cmds.file(path_of_files + frm_name, i=True)
cmds.sets("Mesh", edit=True, forceElement="boneShader")
frm_mesh_name = "frm" + curr_digits + "_Mesh"
cmds.sets(frm_mesh_name, edit=True, forceElement="skinShader")
cmds.select('Mesh')
cmds.polySoftEdge(a=soften_angle)
cmds.select(frm_mesh_name)
cmds.polySoftEdge(a=soften_angle)
#load the point cloud
if draw_points:
point_cloud_file = path_of_files + "frm" + curr_digits + ".xyz"
load_xyz( point_cloud_file )
path_to_file = cmds.render()
if path_to_file[-3:] != "png":
print "Render is NOT outputting pngs! Quitting..."
break
#rename the rendered file
output_name = "frame" + curr_digits + ".png"
split_path = path_to_file.split('/')
split_path[-1] = output_name
new_path = "/".join(split_path)
#os.rename(path_to_file, new_path)
move(path_to_file, new_path)
print 'RENDERED TO: ', new_path
#delete the meshes
if draw_mesh:
cmds.select('Mesh')
cmds.delete()
frm_mesh_name = "frm" + curr_digits + "_Mesh"
cmds.select(frm_mesh_name)
cmds.delete()
#delete the point cloud
if draw_points:
del_pointcloud()
frames_rendered = frames_rendered + 1
if frames_rendered > max_num_frames:
break
#show our templates
cmds.showHidden( "template_skin" )
cmds.showHidden( "template_bone" )
load_xyz( path_of_files + "frm0000.xyz" )
def unhideAll(self):
for obj in mc.ls(o=1, typ= "transform"):
if obj not in self.lastSelection:
mc.showHidden(obj)
