def desIsolate(): """desisolate""" currPanel = mc.getPanel( withFocus = True ); panelType = mc.getPanel( to = currPanel ) if panelType == 'modelPanel': mc.isolateSelect( currPanel, state = 0 ) mm.eval( 'enableIsolateSelect %s 0;'%currPanel )
def set_isolate_set(selected):
set_name = get_isolate_set_name()
# Trying to hide visible children in hierarchy to get wanted isolate
# behavior.
for sel in selected:
for child in sel.iterchildren():
if child in selected or not child.type == MFn.kTransform:
continue
# Only work on visible children
if child.attr['visibility']:
child.attr['visibility'] = False
HIDDEN_CHILDREN.add(child)
hilited = DagpathList(
[dag for dag in mampy.daglist(hl=True) if dag not in selected]
)
if hilited:
cmds.hilite(hilited.cmdslist(), toggle=True)
# In case the dag object was a child of unhilited object rehilite it.
for dag in selected:
cmds.hilite(str(dag))
if not set_name:
for dag in selected:
cmds.isolateSelect(get_active_panel(), addDagObject=str(dag))
return
cmds.sets(clear=set_name)
cmds.sets(selected.cmdslist(), include=set_name)
def addMembers(self, nodes=om.MSelectionList()):
self._members.merge(nodes)
if self._state:
om.MGlobal.setActiveSelectionList(nodes)
for pane in self._panes:
cmds.isolateSelect(pane, addSelected=True)
def makeObjectIsolateOn(objectName):
if objectName:
#currentView = cmds.paneLayout('viewPanes', q=True, pane1=True)
currentView = u'modelPanel4'
cmds.select(objectName, replace=True)
cmds.isolateSelect(currentView, state=1)
def main(b_isolate=True):
active_panel = cmds.getPanel(wf=True)
model_panel = cmds.getPanel(typ='modelPanel')
src_panel = None
if active_panel and active_panel in model_panel:
src_panel = active_panel
if src_panel:
iso_state = cmds.isolateSelect(src_panel, q=True, state=True)
isExist = True
if b_isolate:
if iso_state == False:
isExist = False
mel.eval('enableIsolateSelect "%s" 1;'%src_panel)
selected = cmds.ls(sl=True)
if selected:
view_object = cmds.isolateSelect(src_panel, q=True, vo=True)
if view_object:
set_members = cmds.sets(view_object, q=True)
if set_members == None:
set_members = []
for sel in selected:
cmds.select(sel,r=True)
if sel in set_members and isExist == True:
cmds.isolateSelect(src_panel, rs=True)
else:
cmds.isolateSelect(src_panel, addSelected=True)
cmds.isolateSelect(src_panel,u=True)
cmds.select(selected, r=True)
elif b_isolate == False and iso_state:
cmds.isolateSelect(src_panel, state=False)
def removeMembers(self, nodes=om.MSelectionList()):
self._members.merge(nodes, om.MSelectionList().kRemoveFromList )
if self._state:
om.MGlobal.setActiveSelectionList(nodes)
for pane in self._panes:
cmds.isolateSelect(pane, removeSelected=True)
def isolated_nodes(nodes, panel):
"""Context manager for isolating `nodes` in `panel`"""
if nodes is not None:
cmds.isolateSelect(panel, state=True)
for obj in nodes:
cmds.isolateSelect(panel, addDagObject=obj)
yield
def isolate(self): """isolate node in viewport""" currPanel = mc.getPanel( withFocus = True ) panelType = mc.getPanel( to = currPanel ) if panelType == 'modelPanel': self() mc.isolateSelect( currPanel, state = 1 )
def set_isolate_selected_on():
selected = get_selected_objects()
if not selected:
raise NothingSelected()
cmds.isolateSelect(get_active_panel(), state=True)
set_isolate_set(selected)
create_select_change_event()
def update(arcTracer, forceUpdate=False):
'''Populates an arcTracer with updated spacial information.'''
# Get object to trace
traceObj = getFirstConnection('%s.traceObj' % arcTracer, inAttr=1)
if not traceObj:
om.MGlobal.displayError('Trace object for arc tracer %s disappeared!' % arcTracer)
return
# Get selection so it can be restored later
selection = cmd.ls(sl=1)
# Hide everything but the trace obj in refresh mode
if cmd.getAttr('%s.useRefreshMode' % arcTracer):
cmd.select(traceObj)
panels = cmd.getPanel(typ='modelPanel')
panelsIsolated = []
for panel in panels:
if not cmd.isolateSelect(panel, q=1, state=1):
cmd.isolateSelect(panel, state=1)
panelsIsolated.append(panel)
pastFrames = cmd.getAttr('%s.pastFrames' % arcTracer)
futureFrames = cmd.getAttr('%s.futureFrames' % arcTracer)
# Disable cycle check since the update-frame expression causes a
# cycle (apparently)
try:
# Only recent versions of maya can query the cycle check.
cycleCheck = cmd.cycleCheck(q=1, e=1)
except AttributeError:
cycleCheck = 1
cmd.cycleCheck(e=0)
currentFrame = cmd.currentTime(q=1)
lastFrame = cmd.getAttr('%s.lastFrame' % arcTracer)
timeShift = abs(lastFrame - currentFrame)
if timeShift != 0 or forceUpdate:
frameRange, direction = findFrameRange(pastFrames, futureFrames, currentFrame, lastFrame, timeShift, forceUpdate)
arcPositions = getSavedArcPositions(arcTracer, timeShift, forceUpdate)
# Get updated positions
getUpdatedArcPositions(arcTracer, traceObj, frameRange, currentFrame, direction, arcPositions)
# Set all positions
setArcPositions(arcTracer, arcPositions, pastFrames, futureFrames, currentFrame)
cmd.setAttr('%s.lastFrame' % arcTracer, currentFrame)
cmd.cycleCheck(e=cycleCheck)
# Restore isolation
if cmd.getAttr('%s.useRefreshMode' % arcTracer):
for panel in panelsIsolated:
cmd.isolateSelect(panel, state=0)
# Restore previous selection
cmd.select(selection)
def isolate( node ): """isolate node""" nod = mn.Node( node ) nod() currPanel = mc.getPanel( withFocus = True ); panelType = mc.getPanel( to = currPanel ) if panelType == 'modelPanel': mc.isolateSelect( currPanel, state = 1 ) mm.eval( 'enableIsolateSelect %s 1;'%currPanel )
def isolatePanes(self, panes=[]):
sel = om.MSelectionList()
om.MGlobal.getActiveSelectionList(sel)
om.MGlobal.setActiveSelectionList(self._members)
for pane in panes:
cmds.isolateSelect(pane, state=True)
cmds.isolateSelect(pane, addSelected=True) # Why is this necessary, I dont care
om.MGlobal.setActiveSelectionList(sel)
def reset_view(self):
"""
return current view panel to original settings
"""
mc.isolateSelect(self._current_panel, state=False)
# mel.eval('enableIsolateSelect %s %s;' % (self._current_panel, False))
mc.modelEditor(
self._current_panel,
edit=True,
displayAppearance=self.display_defaults["appearance"],
displayTextures=self.display_defaults["textures"],
displayLights=self.display_defaults["lights"],
)
def setIsolateSelect(pt, state):
"""
"""
# Check point
if not cmds.objExists(pt):
raise Exception('Object "' + pt + '" does not exist!')
# Select point
cmds.select(pt)
# Get panel list
panelList = cmds.getPanel(type='modelPanel')
# For each panel
for panel in panelList: cmds.isolateSelect(panel, state=state)
def func( *args, **kwargs ): modelPanels = cmd.getPanel( vis=True ) emptySelConn = cmd.selectionConnection() for panel in modelPanels: if cmd.getPanel( to=panel ) == 'modelPanel': cmd.isolateSelect( panel, state=True ) cmd.modelEditor( panel, e=True, mlc=emptySelConn ) try: return f( *args, **kwargs ) finally: for panel in modelPanels: if cmd.getPanel( to=panel ) == 'modelPanel': cmd.isolateSelect( panel, state=False ) cmd.deleteUI( emptySelConn )
def createJointAtPoint(radius=30):
sel = cmds.ls(sl=1)
hi = cmds.ls(hilite=1)[0]
vtx = cmds.filterExpand(sm=31)
pos = [0.0,0.0,0.0]
for v in vtx:
p = cmds.xform(v, q=1, t=1, ws=1)
for i in range(3):
pos[i] = pos[i] + p[i]
for i in range(3):
pos[i] = pos[i] / len(vtx)
cmds.select(d=1)
cmds.joint(p=pos, radius=radius)
cmds.isolateSelect('modelPanel4',addSelected=1)
cmds.select(hi)
cmds.hilite(replace=1)
cmds.selectType(ocm=1,vertex=1)
def bakeLocatorsToAnimControls(controlsToBake):
print "\nBaking Locators to Controls..."
selBckp = cmds.ls(selection=True)
start = int(cmds.playbackOptions(q=True, minTime=True))
end = int(cmds.playbackOptions(q=True, maxTime=True))
currentViewport = cmds.getPanel(wf=True)
isolateState = cmds.isolateSelect(currentViewport, q=True, state=True)
cmds.select(clear=True)
cmds.isolateSelect(currentViewport, state=1)
cmds.select(controlsToBake, replace=True)
cmds.isolateSelect(currentViewport, addSelected=True )
if len(controlsToBake) > 0:
cmds.waitCursor(state=True)
for i in range(start, end + 1):
print ("\nCurrent Frame -> " + str(i))
cmds.currentTime(i, update=True)
for ctrl in controlsToBake:
print ("\nControl -> " + ctrl)
# gets the bake locator for this control or creates if not exists
bakeLocator = getControlBakeLocator(ctrl)
print ("Baking into Locator -> " + bakeLocator)
# now this locator must be keyed and aligned along the timeline to the anim control creating keys by frame
#get the transform values of the control
cmds.select(ctrl, replace=True)
position = cmds.xform(query=True, translation=True, worldSpace=True)
rotation = cmds.xform(query=True, rotation=True, worldSpace=True)
# locates the locator
cmds.setAttr((bakeLocator + ".translateX"), position[0])
cmds.setAttr((bakeLocator + ".translateY"), position[1])
cmds.setAttr((bakeLocator + ".translateZ"), position[2])
cmds.setAttr((bakeLocator + ".rotateX"), rotation[0])
cmds.setAttr((bakeLocator + ".rotateY"), rotation[1])
cmds.setAttr((bakeLocator + ".rotateZ"), rotation[2])
# creates the key for that frame
cmds.select(bakeLocator, replace=True)
cmds.setKeyframe()
cmds.waitCursor(state=False)
cmds.isolateSelect(currentViewport, state=isolateState)
cmds.currentTime(start, update=True)
cmds.select(clear=True)
cmds.select(selBckp, replace=True)
print "\n...Locators Baked to Controls\n"
def isolateSelection():
"""
This definition isolates current selection.
"""
panel = cmds.getPanel(withFocus=True)
try:
mel.eval("enableIsolateSelect {0} {1};".format(panel, str(not cmds.isolateSelect(panel, q=True, state=True)).lower()))
except:
pass
def replaceMembers(self, nodes=om.MSelectionList(), setDefault=False):
self._members = nodes
if setDefault:
self.setDefaultMemory(self._members)
if self._state:
sel = om.MSelectionList()
om.MGlobal.getActiveSelectionList(sel)
om.MGlobal.setActiveSelectionList(nodes)
for pane in self._panes:
cmds.isolateSelect(pane, loadSelected=True)
cmds.isolateSelect(pane, addSelected=True)
om.MGlobal.setActiveSelectionList(sel)
def bakeAnimControlsToLocators(bakedLocators):
print "\nBaking Controls to Locators..."
selBckp = cmds.ls(selection=True)
start = int(cmds.playbackOptions(q=True, minTime=True))
end = int(cmds.playbackOptions(q=True, maxTime=True))
currentViewport = cmds.getPanel(wf=True)
isolateState = cmds.isolateSelect(currentViewport, q=True, state=True)
cmds.select(clear=True)
cmds.isolateSelect(currentViewport, state=1)
cmds.select(bakedLocators, replace=True)
cmds.isolateSelect(currentViewport, addSelected=True )
if len(bakedLocators) > 0:
cmds.waitCursor(state=True)
for i in range(start, end + 1):
print ("\nCurrent Frame -> " + str(i))
cmds.currentTime(i, update=True)
for loc in bakedLocators:
print ("\nLocator -> " + loc)
# gets the anim control for this bake locator
animControl = getBakeLocatorControl(loc)
if animControl is not None:
print ("Baking into Locator -> " + animControl)
# now this anim control must be keyed and aligned along the timeline to the bake locator creating keys by frame
#get the transform values of the locator
cmds.select(loc, replace=True)
bakedPosition = cmds.xform(query=True, translation=True, worldSpace=True)
bakedRotation = cmds.xform(query=True, rotation=True, worldSpace=True)
# locates the anim control
cmds.select(animControl, replace=True)
cmds.xform(absolute=True, worldSpace=True, rotation=bakedRotation)
cmds.xform(absolute=True, worldSpace=True, translation=bakedPosition)
# creates the key for that frame
cmds.select(animControl, replace=True)
cmds.setKeyframe()
cmds.waitCursor(state=False)
cmds.isolateSelect(currentViewport, state=isolateState)
cmds.currentTime(start, update=True)
cmds.select(clear=True)
cmds.select(selBckp, replace=True)
print "\n...Controls Baked to Locators\n"
def prep_view(self):
"""
prep current view panel with required settings for screen grab
"""
mel.eval("lookThroughModelPanel %s %s" % (self.camera, self._current_panel))
if self._isolate_objs:
# mel.eval('enableIsolateSelect %s %s;' %
# (self._current_panel, self._isolate_objs))
mc.isolateSelect(self._current_panel, state=self._isolate_objs)
mc.isolateSelect(self._current_panel, addSelected=True)
mc.viewFit()
mc.select(clear=True)
# attempt to use Viewport 2.0 for better image
try:
mc.modelEditor(self._current_panel, edit=True, rendererName="vp2Renderer")
except Exception, e:
raise "Issue activating Viewport 2.0. %s" % e
def isolateBtnClick(self):
self.isolateSwitch = 0 if self.isolateSwitch else 1
print('isolate')
items = self.scene.items()
outObjs = set()
for item in items:
itemType = type(item)
if itemType == myEllipseItem or itemType == myRectItem:
objs = item.getObjs()
for obj in objs:
refObjs = cmds.referenceQuery(obj, n=True, dp=True)
outObjs = outObjs | set([self.getTopPos(refObjs)])
print(list(outObjs))
cmds.select(list(outObjs))
panels = cmds.getPanel(type='modelPanel')
for pan in panels:
cmds.isolateSelect(pan, state=self.isolateSwitch)
cmds.select(cl=True)
def openTransform():
controlObj = cmds.ls(selection=True)
parentObject = cmds.listRelatives(controlObj[0], parent=True)[0]
print ("parentObject= %s" % parentObject)
constraint = cmds.listConnections(controlObj[0], type="parentConstraint")[0]
print ("constraint= %s" % constraint)
joints = cmds.listConnections(constraint, type="joint")[0]
print ("joints= %s" % joints)
skinCluster = cmds.listConnections(joints, type="skinCluster")[0]
print ("skinCluster= %s" % skinCluster)
geometry = cmds.listConnections(skinCluster, type="mesh")[0]
print ("geometry= %s" % geometry)
cmds.select(geometry, replace=True)
cmds.select(parentObject, add=True)
cmds.isolateSelect("modelPanel4", state=1)
cmds.isolateSelect("modelPanel4", loadSelected=1)
print ("isolating = \n%s, \n%s" % (geometry, parentObject))
cmds.select(parentObject, replace=True)
cmds.delete(constraint)
return joints, controlObj
def set_isolate_selected_off_or_update():
global SELECT_CHANGE_EVENT
isoset = mampy.daglist(cmds.sets(get_isolate_set_name(), q=True))
selset = get_selected_objects()
if isoset:
if isoset == selset or not selset:
try:
MEventMessage.removeCallback(SELECT_CHANGE_EVENT)
SELECT_CHANGE_EVENT = None
except RuntimeError:
pass
cmds.isolateSelect(get_active_panel(), state=False)
# Show hidden children again and clear HIDDEN_CHILDREN list to
# avoid uncertain clashes.
for child in HIDDEN_CHILDREN:
child.attr['visibility'] = True
HIDDEN_CHILDREN.clear()
else:
set_isolate_set(selset)
def isolate(state, sel=None, panel=None):
"""
Isolated selected objects in the specified model panel
@param state: Rig namespace to bake mocap override keys for.
@type state: bool
@param sel: List of objects to isolate in the viewport. If [], use current selection. If None, show nothing.
@type sel: list
@param panel: The model viewport to enable isolateSelected for. If empty, use model panel with focus.
@type panel: str
"""
# ==========
# - Checks -
# ==========
# Check Selection
if (sel != None) and (not sel): sel = cmds.ls(sl=1)
# Check Panel
if not panel:
try:
panel = getPanel()
except:
print('Unable to determine model panel! Aborting...')
return
# ====================
# - Isolate Selected -
# ====================
if state:
# Clear Selection
cmds.select(cl=True)
# Isolate Selected - Enable
cmds.isolateSelect(panel, state=True)
# Update Selection
if sel: cmds.select(sel)
# Load Selected
cmds.isolateSelect(panel, loadSelected=True)
# Update Isolate Set
cmds.isolateSelect(panel, update=True)
else:
# Isolate Selected - Disable
cmds.isolateSelect(panel, state=False)
def toggleIsolateSelected():
'''Toggles Isolate Selected'''
cmds.undoInfo(swf=0)
try:
panel = cmds.getPanel(wf=1)
if cmds.isolateSelect(panel,q=1,s=1):
cmds.isolateSelect(panel,s=0)
else :
cmds.isolateSelect(panel,s=1)
cmds.isolateSelect(panel,addSelected=1)
except Exception, e:
print e
def saveState(self):
self.saveTime = self.tdStats.emit('save', True)
activeViewport = tdLib.getActiveViewport()
if self.exportList == False:
# Do not export, use the original scene
logger.debug('Use original scene.')
self.pathScene = cmds.file(sceneName=True, query=True)
self.pathPickle = tdLib.formatPath(self.uuid + '.pickle', self.tmp)
else:
if activeViewport and not self.exportList:
isolateSets = cmds.isolateSelect(activeViewport, viewObjects=True, query=True)
if isolateSets:
# remove mskMaterial and tmpObjFinal when baking is fixed
self.exportList = cmds.sets(isolateSets, query=True) + cmds.ls(type='textureBakeSet') + cmds.ls('mskMaterial*') + cmds.ls('tmpObjFinal_outPlaceHolderShape')
logger.debug('Export {}'.format(self.exportList))
self.pathScene = tdLib.export(self.exportList, path=self.tmp, suffix=self.uuid) # If the export list is empty, it will export everything
self.pathPickle = tdLib.replaceExtension(self.pathScene, '.pickle')
tdLib.pickleObject(self.pathPickle, self.objectRecorded)
self.saveTime.stop()
def initViewBtns(self):
for modelPanel in ("modelPanel1", "modelPanel2", "modelPanel3", "modelPanel4"):
state = cmds.isolateSelect(modelPanel, query=True, state=True)
self.panelStates[modelPanel] = state
if state:
self._isolate._state = True
self.isolateBTN.setChecked(True)
self._isolate.addPanes([modelPanel])
for page in self.stackedWidget.children():
for btn in page.findChildren(QtGui.QPushButton):
btn.setCheckable(True)
panel = btn.property("view")
btns = self.viewBtns.setdefault(panel, [])
btns.append(btn)
def isolateObj(state) :
currentPane = mc.paneLayout('viewPanes', q=True, pane1=True)
mc.isolateSelect( currentPane, state=state )
def save_snapshot(self, geo):
# Create new camera, isolated selected object, frame and take snapshot
# Delete cam and return to perspective cam
self.create_img_cam()
cmds.lookThru(self.cameraName)
cmds.select(geo)
if cmds.isolateSelect('modelPanel4', q=True, state=True):
cmds.isolateSelect('modelPanel4', state=False)
cmds.isolateSelect('modelPanel4', state=True)
cmds.isolateSelect('modelPanel4', addSelected=True)
else:
cmds.isolateSelect('modelPanel4', state=True)
cmds.isolateSelect('modelPanel4', addSelected=True)
cmds.viewFit()
imageSnapshot = (os.path.join(self.img_path, geo)) + ".jpg"
imageSnapshot = os.path.normpath(imageSnapshot)
cmds.refresh(cv=True, fe = "jpg", fn = imageSnapshot)
cmds.isolateSelect('modelPanel4', state=False)
self.return_to_perspCam()
if self.cameraName:
cmds.delete(self.cameraName[0])
return imageSnapshot
def guardaImagen(nombreDePose=""):
global nombreDePoseGlobal
nombreDePoseGlobal = nombreDePose
seleccion = mc.ls(sl=1)
mc.evalDeferred('resolucion=150')
nombrePanel = mc.modelPanel(tearOff=True)
nombreEditor = mc.modelPanel(nombrePanel, q=1, modelEditor=1)
mc.modelEditor(
nombreEditor,
e=1,
activeOnly=0,
displayAppearance="smoothShaded",
polymeshes=1,
wos=0,
nurbsSurfaces=1,
planes=1,
lights=0,
cameras=0,
controlVertices=0,
grid=0,
hulls=0,
joints=1,
ikHandles=0,
nurbsCurves=0,
deformers=0,
dynamics=1,
fluids=0,
hairSystems=0,
follicles=0,
nCloths=1,
nParticles=1,
nRigids=1,
dynamicConstraints=0,
locators=0,
manipulators=0,
dimensions=0,
handles=0,
pivots=1,
textures=0,
strokes=0,
pluginShapes=1,
queryPluginObjects=1,
)
grupoDeLaSeleccion = mc.ls(sl=1)[0].split("|")[0]
mc.select(grupoDeLaSeleccion)
mc.isolateSelect(nombrePanel, state=1)
mc.select(cl=1)
mc.modelEditor(nombreEditor,
e=1,
activeView=1,
p='lay_1',
activeOnly=0,
displayAppearance="smoothShaded",
polymeshes=1,
wos=0)
mc.evalDeferred('view=apiUI.M3dView.active3dView()')
mc.evalDeferred('imagen=api.MImage()')
mc.evalDeferred('view.readColorBuffer (imagen,True)')
mc.evalDeferred('imagen.resize (resolucion,resolucion,1)')
mc.evalDeferred(
'imagen.writeToFile("x:/PH_SCRIPTS/ICONS/POSES/"+nombreDePoseGlobal+".png","png")'
)
mc.isolateSelect(nombrePanel, state=0)
mc.select(seleccion)
def export_animation_into_video(root_node_name,
save_dir='./',
save_filename='',
start_time=0,
end_time=240):
"""Export animation of a node into video file.
Args:
root_node_name: str
Name of root joint.
save_dir: str
Directory to save video files.
save_filename: str
Video filename. The full file path is : {save_dir}/{save_filename}
If set None or a null string, filename will be automaticly set to:
<scane_name>.animation.<root_node_name>.<ext>
<ext>: depending on your OS system, e.g. .mov on MacOS.
start_time: int
Start frame of animation
end_time: int
End frame of animation
If end_time<start_time or end_time<0, will use "setPlaybackRangeToMinMax" to set start_time and end_time automatically.
Returns:
Full absolute path of saved file.
"""
pprint("===> root_node_name: {}".format(root_node_name))
pprint("===> save_dir: {}".format(save_dir))
if not osp.exists(save_dir):
os.makedirs(save_dir)
# save_dir = osp.abspath(save_dir)
scene_name = get_current_scene_name()
if not save_filename:
save_filename = '{}.animation.{}'.format(
scene_name, root_node_name.replace(':', '-'))
output_filename = osp.join(save_dir, save_filename)
pprint("===> output file: {}".format(output_filename))
# num_frames = cmds.keyframe(root_node_name, q=True, keyframeCount=True) / 6
# num_frames = get_keyframe_count(root_node_name)
# pprint('===> {} keyframes in total'.format(num_frames))
pprint('===> start_time: {}'.format(start_time))
pprint('===> end_time: {}'.format(end_time))
cmds.currentTime(0)
"""MEL
string $isolated_panel = `paneLayout -q -pane1 viewPanes`;
isolateSelect -state 0 $isolated_panel;
isolateSelect -update $isolated_panel;
select -r $driven_node;
isolateSelect -state 1 $isolated_panel;
playblast -filename $export_filename -offScreen -startTime $start_time -endTime $end_time -format avfoundation -sequenceTime 0 -clearCache 1 -viewer 1 -showOrnaments 1 -fp 4 -percent 100 -compression "H.264" -quality 70;
"""
# isolate selected object (make it the only active one)
isolated_panel = cmds.paneLayout("viewPanes", query=True, pane1=True)
cmds.isolateSelect(isolated_panel, state=True)
cmds.isolateSelect(isolated_panel, update=True)
cmds.select(root_node_name, replace=True)
cmds.isolateSelect(isolated_panel, loadSelected=True)
if end_time < start_time or end_time <= 0:
pprint('===> setPlaybackRangeToMinMax')
mel.eval('setPlaybackRangeToMinMax')
cmd_str = 'playblast -filename "{}" -offScreen -format avfoundation -sequenceTime 0 -clearCache 1 -viewer 1 -showOrnaments 1 -fp 4 -percent 100 -compression "H.264" -quality 70;'.format(
output_filename, start_time, end_time)
pprint('===> run command: ')
pprint(cmd_str)
else:
cmd_str = 'playblast -filename "{}" -offScreen -startTime {} -endTime {} -format avfoundation -sequenceTime 0 -clearCache 1 -viewer 1 -showOrnaments 1 -fp 4 -percent 100 -compression "H.264" -quality 70;'.format(
output_filename, start_time, end_time)
pprint('===> run command: ')
pprint(cmd_str)
# de-isolate
cmds.isolateSelect(isolated_panel, state=False)
output_filename = mel.eval(cmd_str)
output_filename = osp.abspath(output_filename)
pprint("===> full path of output file: {}".format(output_filename))
return output_filename
"""
Selecciona y aisla los joints que contiene el skin junto al mesh. Activa skinning weights.
"""
import maya.cmds as mc
import maya.mel as mel
selGeo = mc.ls (sl=True)
if selGeo:
try:
influenceJoints = mc.skinCluster (selGeo, query=True, influence=True)
mc.select (influenceJoints, add=True)
isoPnl = mc.getPanel(wf=True)
isoCrnt = mc.isolateSelect(isoPnl, q=True, s=True)
mel.eval('enableIsolateSelect %s %d' % (isoPnl,not isoCrnt) )
mel.eval('ArtPaintSkinWeightsToolOptions; changeSelectMode -object; select -add %s' %selGeo[0])
except :
mc.warning('No se pudo. Tal vez no sea algo con skin...' )
def isolate(self, state):
mc.select(clear=True)
for each in self.modelPanels:
mc.isolateSelect(each, state=state)
def _createThumbnail(self, assetName, selectionOnly=True, viewFit=True):
ssResolution = 1000
thumbPath = os.path.join(self.directory, assetName, "%s_thumb.jpg" % assetName)
SSpath = os.path.join(self.directory, assetName, "%s_s.jpg" % assetName)
WFpath = os.path.join(self.directory, assetName, "%s_w.jpg" % assetName)
selection = cmds.ls(sl=True)
# if not update:
if not selectionOnly:
# deselect if you dont want to focus only on the selection
selection = cmds.ls(type="transform")
cmds.select(d=True)
## CREATE A CUSTOM PANEL WITH DESIRED SETTINGS
try:
currentCam = cmds.modelPanel(cmds.getPanel(wf=True), q=True, cam=True)
vRenderer = cmds.modelEditor(cmds.getPanel(wf=True), q=True, rnm=True)
except RuntimeError:
currentCam = u'persp'
vRenderer = 'vp2Renderer'
tempWindow = cmds.window(title="AssetLibrary_SS",
widthHeight=(ssResolution * 1.1, ssResolution * 1.1),
tlc=(0, 0))
cmds.paneLayout()
pbPanel = cmds.modelPanel(camera=currentCam)
cmds.showWindow(tempWindow)
cmds.setFocus(pbPanel)
cmds.modelEditor(pbPanel, edit=True, rendererName=vRenderer)
########################################
# make sure the viewport display is suitable
# panel = cmds.getPanel(wf=True)
#
# if cmds.getPanel(to=panel) != "modelPanel":
# panel = cmds.getPanel(wl="Persp View")
cmds.modelEditor(pbPanel, e=1, allObjects=1)
cmds.modelEditor(pbPanel, e=1, da="smoothShaded")
cmds.modelEditor(pbPanel, e=1, displayTextures=1)
cmds.modelEditor(pbPanel, e=1, wireframeOnShaded=0)
if viewFit:
cmds.viewFit()
if selectionOnly:
cmds.isolateSelect(pbPanel, state=1)
cmds.isolateSelect(pbPanel, addSelected=True)
# temporarily deselect
cmds.select(d=True)
cmds.setAttr("defaultRenderGlobals.imageFormat", 8) # This is the value for jpeg
frame = cmds.currentTime(query=True)
# thumb
cmds.playblast(completeFilename=thumbPath, forceOverwrite=True, format='image', width=200, height=200,
showOrnaments=False, frame=[frame], viewer=False)
# screenshot
cmds.playblast(completeFilename=SSpath, forceOverwrite=True, format='image', width=1600, height=1600,
showOrnaments=False, frame=[frame], viewer=False)
# Wireframe
cmds.modelEditor(pbPanel, e=1, displayTextures=0)
cmds.modelEditor(pbPanel, e=1, wireframeOnShaded=1)
cmds.playblast(completeFilename=WFpath, forceOverwrite=True, format='image', width=1600, height=1600,
showOrnaments=False, frame=[frame], viewer=False)
## remove window when pb is donw
cmds.deleteUI(tempWindow)
# print panel
cmds.select(selection)
return thumbPath, SSpath, WFpath
