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