def on_btn_ok_clicked(self): print 'btn_ok_clicked' with pymel.UndoChunk(): make_planer.project_vertex(mode=self.cb_mode.currentText(), x=self.rb_x.isChecked(), y=self.rb_y.isChecked(), z=self.rb_z.isChecked())
def keyObj(model, object_names): """ Set the keyframe in the controls pass by a list in obj_names variable :param model: Name of the namespace that will define de the model :param object_names: names of the controls, without the name space :return: None """ with pm.UndoChunk(): nodes = [] nameSpace = getNamespace(model) for name in object_names: if nameSpace: node = getNode(nameSpace + ":" + name) else: node = getNode(name) if not node: continue if not node and nameSpace: mgear.log("Can't find object : %s:%s" % (nameSpace, name), mgear.sev_error) elif not node: mgear.log("Can't find object : %s" % (name), mgear.sev_error) nodes.append(node) if not nodes: return pm.setKeyframe(*nodes)
def mouseReleaseEvent_(self, event): # type: (QtGui.QMouseEvent) -> None if not self.origin: self.origin = event.pos() selected = [] rect = QtCore.QRect(self.origin, event.pos()).normalized() for child in self.findChildren(widgets.SelectButton): # if rect.intersects(child.geometry()): if rect.intersects(self._getButtonAbsoluteGeometry(child)): selected.append(child) if selected: firstLoop = True with pm.UndoChunk(): for wi in selected: wi.rectangleSelection(event, firstLoop) firstLoop = False else: if event.modifiers() == QtCore.Qt.NoModifier: pm.select(cl=True) pm.displayInfo("Clear selection") self.origin = None QtWidgets.QWidget.mouseReleaseEvent(self, event)
def _importConfiguration(configDict): with pm.UndoChunk(): for sm in configDict["softMods"]: smConfig = configDict[sm] targets = [] for t in smConfig["affected"]: try: targets.append(pm.PyNode(t)) except pm.MayaNodeError: pm.displayWarning("{}: has not been found in the scene " "and will be skipped".format(t)) name = smConfig["name"] parent = smConfig["rootParent"] size = smConfig["iconSize"] grp = smConfig["grpName"] rootMatrix = datatypes.Matrix(smConfig["rootMatrix"]) softModNode, baseCtl, tweakCtl = createSoftTweak(name, targets=targets, parent=parent, t=rootMatrix, grp=grp, size=size) if softModNode: ctlBaseMatrix = datatypes.Matrix(smConfig["baseCtlMatrix"]) ctlMatrix = datatypes.Matrix(smConfig["ctlMatrix"]) baseCtl.setMatrix(ctlBaseMatrix, objectSpace=True) tweakCtl.setMatrix(ctlMatrix, objectSpace=True) tweakCtl.falloff.set(smConfig["falloff"]) # we have to set the matrix again on the root because is stored # in local space baseCtl.getParent().setMatrix(rootMatrix, objectSpace=True)
def createSoftTweak(name, targets=[], parent=None, t=None, grp=None, size=0.5, nameExt="softMod", is_asset=False): with pm.UndoChunk(): if isinstance(targets, basestring): targets = pm.PyNode(targets) if not isinstance(targets, list): targets = [targets] if not targets: pm.displayWarning("Can't find the targets to apply to " "softModTweak or Targets not selectedIndexes") return False, False, False # namespace basic handling # NOTE: Doesn't support more than one namespace stacked if pm.ls(parent) and len(name.split(":")) < 2: name = pm.PyNode(parent).namespace() + name baseCtl, tweakCtl = _createSoftTweakControls(name, parent, t, grp, size) if baseCtl: softModNode = _createSoftModTweak(baseCtl, tweakCtl, name, targets, nameExt, is_asset) return softModNode, baseCtl, tweakCtl else: return False, False, False
def selectObj(model, object_names, mouse_button, key_modifier): if not model: return nameSpace = getNamespace(model) with pm.UndoChunk(): nodes = [] for name in object_names: if nameSpace: node = getNode(nameSpace + ":" + name) else: node = getNode(name) if not node: continue if not node and nameSpace: mgear.log("Can't find object : %s:%s" % (nameSpace, name), mgear.sev_error) elif not node: mgear.log("Can't find object : %s" % (name), mgear.sev_error) nodes.append(node) if not nodes: return if mouse_button == QtCore.Qt.RightButton: mirrorPose(False, nodes) return if mouse_button == QtCore.Qt.MiddleButton: mirrorPose(True, nodes) return # Key pressed if key_modifier is None: pm.select(nodes) elif key_modifier == QtCore.Qt.NoModifier: # No Key pm.select(nodes) elif key_modifier == QtCore.Qt.ControlModifier: # ctrl pm.select(nodes, deselect=True) elif key_modifier == QtCore.Qt.ShiftModifier: # shift pm.select(nodes, toggle=True) elif int(key_modifier) == (QtCore.Qt.ControlModifier | QtCore.Qt.ShiftModifier): # ctrl + shift pm.select(nodes, add=True) elif key_modifier == QtCore.Qt.AltModifier: # alt pm.select(nodes) elif int(key_modifier) == (QtCore.Qt.ControlModifier | QtCore.Qt.AltModifier): # ctrl + alt pm.select(nodes, deselect=True) elif int(key_modifier) == (QtCore.Qt.ShiftModifier | QtCore.Qt.AltModifier): # shift + alt pm.select(nodes, toggle=True) elif int(key_modifier) == ( QtCore.Qt.ControlModifier | QtCore.Qt.AltModifier | QtCore.Qt.ShiftModifier): # Ctrl + alt + shift pm.select(nodes, add=True) else: pm.select(nodes)
def smart_loop(): with pm.UndoChunk(): for obj in pm.ls(sl=True): for curve in pm.keyframe(obj, q=True, name=True): first = pm.findKeyframe(curve, which='first') last = pm.findKeyframe(curve, which='last') t = (first, last) pm.copyKey(curve) pm.pasteKey(curve, time=last, option='insert', connect=True)
def on_btn_anim_export_clicked(self): log.info('on_btn_anim_export_clicked') main_net = pymel.PyNode('Main_Net') with pymel.UndoChunk(): main = pymel.PyNode('Main_Net') root = main.jnts[0] anim_utils.bake_anim(root) anim_utils.export_anim(root) pymel.undo()
def export_skinned_mesh(skinned_mesh, output_path, go_to_bind_pose=True): with pm.UndoChunk(): if go_to_bind_pose: bind_pose = skinutils.get_bind_pose_from_skinned_mesh(skinned_mesh) pm.dagPose(bind_pose, restore=True, g=True) with selutils.preserve_selection(): dup_mesh, dup_root, dup_cluster = skinutils.duplicate_skinned_mesh_and_skeleton( skinned_mesh, dup_namespace=NAMESPACE_SKINCOPY_EXPORT, dup_parent=nsutils.PARENT_WORLD) pm.select((dup_mesh, dup_root), replace=True) pm.exportSelected(output_path, constraints=False, expressions=False, shader=False, preserveReferences=False, type='mayaAscii', constructionHistory=True, force=True) pm.undo()
def on_btn_build_humanoid_clicked(self): log.info('on_btn_build_humanoid_clicked') start_time = pymel.timerX() self.progress_bar = QtWidgets.QProgressBar(self) self.pb_main.setValue(0) self.pb_main.show() with pymel.UndoChunk(): build_rig.build_humanoid_rig(self.pb_main, mirror=False) log.info('Duration = {} seconds'.format(pymel.timerX(st=start_time)))
def undo_chunk(*args, **kwargs): with pm.UndoChunk(): print_args = [ x for x in args if (not type(x) == dict) and (not type(x) == list) ] process = System.Diagnostics.Process.GetCurrentProcess() v1_core.v1_logging.get_logger().debug( "{0} - {1} - Undoable ---> {2}.{3} ~~ Args:{4} Kwargs:{5}". format(process.ProcessName, process.Id, undo_method.__module__, undo_method.__name__, print_args, kwargs)) return undo_method(*args, **kwargs)
def repair(cls, instance): with maya.maintained_selection(): with pc.UndoChunk(): temp_transform = pc.polyCube()[0] attributes = cls.get_invalid_attributes(instance, compute=False) for attr in attributes: source = pc.PyNode("{}.{}".format( temp_transform.getShape(), attr.attrName())) attr.set(source.get()) pc.delete(temp_transform)
def smart_offset(offset = 0): with pm.UndoChunk(): for obj in pm.ls(sl=True): for curve in pm.keyframe(obj, q=True, name=True): old_keys = pm.keyframe(curve, q=True, timeChange=True) pm.keyframe(curve, timeChange=offset, relative=True) keys = old_keys + pm.keyframe(curve, q=True, timeChange=True) keys = list(set(keys)) for t in old_keys: pm.setKeyframe(curve, time=t, insert=True) for t in keys: if t > old_keys[-1] or t < old_keys[0]: pm.cutKey(curve, time=t, clear=True)
def applyChannelConfig(self): with pm.UndoChunk(): configDict = self._buildConfigDict() #TODO add checker to avoid error if the datas is not found in the scene for rule in configDict["map"]: # proxy if rule[3]: source = pm.PyNode("{}.{}".format(rule[1], rule[0])) target = pm.PyNode(rule[2]) att.addProxyAttribute(source, target, configDict["proxyPolicy"]) #move else: source = pm.PyNode(rule[1]) target = pm.PyNode(rule[2]) att.moveChannel(rule[0], source, target, configDict["movePolicy"])
def selectObj(model, object_names, mouse_button, key_modifier): with pm.UndoChunk(): nodes = [] for name in object_names: if len(model.split(":")) == 2: node = pm.PyNode( model.split(":")[0] + ":" + name) else: node = pm.PyNode(name) if not node and len(model.split(":")) == 2: mgear.log("Can't find object : %s:%s"%( model.split(":")[0], name), mgear.sev_error) elif not node: mgear.log("Can't find object : %s"%( name), mgear.sev_error) nodes.append(node) if not nodes: return if mouse_button == QtCore.Qt.RightButton: mirrorPose(False, nodes) return if mouse_button == QtCore.Qt.MiddleButton: mirrorPose(True, nodes) return # Key pressed if key_modifier is None: pm.select(nodes) elif key_modifier == QtCore.Qt.NoModifier:# No Key pm.select(nodes) elif key_modifier == QtCore.Qt.ControlModifier: # ctrl pm.select(nodes, add=True) elif key_modifier == QtCore.Qt.ShiftModifier: # shift pm.select(nodes, toggle=True) elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.ShiftModifier: # ctrl + shift pm.select(nodes, deselect=True) elif key_modifier == QtCore.Qt.AltModifier: # alt pm.select(nodes) elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.AltModifier: # ctrl + alt pm.select(nodes, add=True) elif int(key_modifier) == QtCore.Qt.ShiftModifier + QtCore.Qt.AltModifier: # shift + alt pm.select(nodes, toggle=True) elif int(key_modifier) == QtCore.Qt.ControlModifier + QtCore.Qt.AltModifier + QtCore.Qt.ShiftModifier: # Ctrl + alt + shift pm.select(nodes, deselect=True) else: pm.select(nodes)
def replace(before="", after="", search="", replace="", selected=True, missing_only=False): file_nodes = pm.ls(sl=selected, exactType='file') file_nodes.extend(pm.ls(sl=selected, exactType='psdFileTex')) if not file_nodes: pm.warning('No file nodes found!') return before = before.replace('\\', '/') after = after.replace('\\', '/') search = search.replace('\\', '/') replace = replace.replace('\\', '/') # filter missing files if missing_only: missing_files = [] for node in file_nodes: f = node.attr('fileTextureName').get() if not os.path.isfile(f): missing_files.append(node) file_nodes = missing_files with pm.UndoChunk(): for node in file_nodes: old_path = node.attr('fileTextureName').get() old_path = old_path.replace('\\', '/') new_path = old_path if search: new_path = old_path.replace(search, replace) try: node.attr('fileTextureName').set(before + new_path + after) except Exception as e: pm.warning(str(e)) sys.stdout.write('# Replaced %d image name(s)\n' % len(file_nodes))
def mouseReleaseEvent(self, event): if self.rubberband.isVisible(): self.rubberband.hide() selected = [] rect = self.rubberband.geometry() for child in self.findChildren(mwi.SelectButton): if rect.intersects(child.geometry()): selected.append(child) if selected: firstLoop = True with pm.UndoChunk(): for wi in selected: wi.rectangleSelection(event, firstLoop) firstLoop = False else: if event.modifiers() == QtCore.Qt.NoModifier: pm.select(cl=True) pm.displayInfo("Clear selection") QtWidgets.QWidget.mouseReleaseEvent(self, event)
def refit_meshes(target_meshes, driver_mesh): with pm.UndoChunk(): blendshape = [ x for x in driver_mesh.getShape().inputs() if isinstance(x, pm.nt.BlendShape) ][0] initial_weight = blendshape.weight[0].get() blendshape.weight[0].set(0.0) base_shapes = [] for target_mesh in target_meshes: wrap_node, base_shape = create_wrap_deformer( driver_mesh, target_mesh) base_shapes.append(base_shape.getParent()) blendshape.weight[0].set(1.0) # sometimes the target meshes do not get deformed at all until the viewport is refreshed for some reason. pm.refresh() # clearing the history deleted the wrap deformer nodes, but does not delete the base shapes that were created. pm.delete(target_meshes, constructionHistory=True) pm.delete(base_shapes) blendshape.weight[0].set(initial_weight)
def apply_average_weights(self): shape_to_skincl, vert_to_infs_wts = get_shape_to_skincl_and_vert_to_infs_wts( self.sampled_verts) if not self.sampled_verts: return inf_to_wt_totals = get_influence_to_weight_totals(vert_to_infs_wts) pruned_inf_to_weight = get_pruned_influences_to_weights( inf_to_wt_totals, float(len(self.sampled_verts))) target_verts = selectionutils.convert_selection_to_verts() target_skincl = skinutils.get_skincluster(target_verts[0]) with pm.UndoChunk(): with skinutils.max_influences_normalize_weights_disabled( target_skincl): pm.skinPercent(target_skincl, target_verts, transformValue=pruned_inf_to_weight.items()) # Normalize weights after modifying them just our changes didn't equal exactly 1.0. pm.skinPercent(target_skincl, target_verts, normalize=True)
def apply_proximity_weights(self): shape_to_skincl, svert_to_infs_wts = get_shape_to_skincl_and_vert_to_infs_wts( self.sampled_verts) if not self.sampled_verts: return target_verts = selectionutils.convert_selection_to_verts() target_skincl = skinutils.get_skincluster(target_verts[0]) with pm.UndoChunk(): with skinutils.max_influences_normalize_weights_disabled( target_skincl): for target_vert in target_verts: infs_to_weights = get_scaled_influence_to_weight_totals( svert_to_infs_wts, target_vert) pruned_infs_to_weights = get_pruned_influences_to_weights( infs_to_weights) pm.skinPercent( target_skincl, target_vert, transformValue=pruned_infs_to_weights.items()) pm.skinPercent(target_skincl, target_verts, normalize=True)
def create_loc_on_pivot(selection=None, nameScheme=None): """ Create locator on pivot of every selected or given node. If supplied node isn't a transform it checks for a parent transform else it will skip the node. You can supply a nameScheme function to alter the name of the generated locator on a per node base. Args: selection ([iterable], optional): List containing the nodes. Defaults to None. nameScheme ([Function], optional): Function to alter the name of the generated locators. Defaults to None. """ if not selection: selection = pmc.selected() assert selection, "Nothing selected." with pmc.UndoChunk(): for node in selection: if node.type() != "transform": try: par = pmc.listRelatives(node, ap=True)[0] if par in selection: continue node = par except Exception: continue name = node.name() if nameScheme: name = nameScheme(name) else: name = "{0}_loc".format(name) pos = node.getPivots(worldSpace=True)[0] loc = pmc.spaceLocator(n=name) pmc.move(loc, pos)
def copy_paste_offset(): offset = pm.promptDialog(button=['OK', 'Cancel'], defaultButton='OK', dismissString='Cancel', cancelButton='Cancel', title='Copy Offset', message='Copy and paste offset:') if offset == 'Cancel': return try: offset = float(pm.promptDialog(q=True, text=True)) except ValueError: return # get time slider range aTimeSlider = mel.eval('$tmpVar=$gPlayBackSlider') timeRange = [] if cmds.timeControl(aTimeSlider, q=True, rangeVisible=True): timeRange = cmds.timeControl(aTimeSlider, q=True, rangeArray=True) else: timeRange += 2 * [cmds.currentTime(q=True)] timeRange = tuple(timeRange) with pm.UndoChunk(): for o in pm.ls(sl=True): for k in sorted( list( set( pm.keyframe(o, q=True, timeChange=True, time=timeRange)))): pm.copyKey(o, time=(k, k)) pm.pasteKey(o, time=(k, k), timeOffset=offset, option='merge')
def mirror_jnts(objs, **kwargs): # Sort objects by hyerarchy so we mirror parents before their children. objs = sorted(objs, key=libPymel.get_num_parents) with pymel.UndoChunk(): for obj in objs: mirror_jnt(obj, **kwargs)
def on_action_create(self, *args): sName = self.ui.edtNewName.text() # loading Maya matrix node if not (cmds.pluginInfo("decomposeMatrix", query=True, loaded=True)): try: # Maya 2012 cmds.loadPlugin("decomposeMatrix.mll") except: try: # Maya 2013 or earlier cmds.loadPlugin("matrixNodes.mll") except: print self.langDic[ self.langName]['e002_decomposeMatrixNotFound'] aSel = pymel.selected() if (len(aSel) == 2): #Create the container of the system data pData = PoseReaderData() with pymel.UndoChunk(): #Get Needed matrix information pData.nParent = aSel[1] pData.nChild = aSel[0] m4ParentMat = pData.nParent.getMatrix(worldSpace=True) m4ChildMat = pData.nChild.getMatrix(worldSpace=True) #Create the two node needed to extract the rotation pData.nPGrp = pymel.createNode("transform", name=sName + "_PoseReader_Parent_Grp", p=pData.nParent) pData.nPGrp.setMatrix(m4ChildMat, worldSpace=True) pData.nParentLoc = self.createLoc( sName + "_AngExtract_ParentLoc", pData.nPGrp) pData.nCGrp = pymel.createNode("transform", name=sName + "_PoseReader_Child_Grp", p=pData.nChild) pData.nCGrp.setMatrix(m4ChildMat, worldSpace=True) pData.nChildLoc = self.createLoc( sName + "_AngExtract_ChildLoc", pData.nCGrp) #Add usefull attributes for the tool pData.nChildLoc.setDynamicAttr("posereaderdata", True) pData.nChildLoc.addAttr("angleMaxValue", min=-360.0, max=360.0) pData.nChildLoc.setAttr("angleMaxValue", 180, edit=True, keyable=False, lock=False) pData.nChildLoc.addAttr("axis", at="enum", enumName="X:Y:Z") pData.nChildLoc.setAttr("axis", 1, edit=True, keyable=False, lock=False) #Setup the rotation extaction pData.nMultM = pymel.createNode("multMatrix", name=sName + "_ExtactAngle_MM") pymel.connectAttr(pData.nChildLoc.worldMatrix[0], pData.nMultM.matrixIn[0]) pymel.connectAttr(pData.nParentLoc.worldInverseMatrix[0], pData.nMultM.matrixIn[1]) pData.nDecM = pymel.createNode("decomposeMatrix", name=sName + "_ExtractAngle_DM") pymel.connectAttr(pData.nMultM.matrixSum, pData.nDecM.inputMatrix) #Setup the rotation affection pData.nMD = pymel.createNode("multiplyDivide", name=sName + "_NormValue_MD") pData.nMD.operation.set(2) pymel.connectAttr(pData.nDecM.outputRotateY, pData.nMD.input1X) pymel.connectAttr(pData.nChildLoc.angleMaxValue, pData.nMD.input2X) pData.nCD = pymel.createNode("condition", name=sName + "_SmallerThanOne_CD") pymel.connectAttr(pData.nMD.outputX, pData.nCD.firstTerm) pymel.connectAttr(pData.nMD.outputX, pData.nCD.colorIfTrueR) pData.nCD.secondTerm.set(1) pData.nCD.operation.set(5) #Less or equal pData.nCDNoNeg = pymel.createNode("condition", name=sName + "_OverZero_CD") pymel.connectAttr(pData.nCD.outColorR, pData.nCDNoNeg.firstTerm) pymel.connectAttr(pData.nCD.outColorR, pData.nCDNoNeg.colorIfTrueR) pData.nCDNoNeg.secondTerm.set(0) pData.nCDNoNeg.colorIfFalseR.set(0) pData.nCDNoNeg.operation.set(3) #Greater or Equal #Node for manual activation connection pData.nMDActive = pymel.createNode("multiplyDivide", name=sName + "_Active_MD") pymel.connectAttr(pData.nCDNoNeg.outColorR, pData.nMDActive.input1X) #for o in pData.__dict__: #print o libSerialization.export_network(pData) self.addItem(pData) else: pymel.confirmDialog( title='Selection Problem', message='You need to have exactly two nodes selected')
def patternSelection(): with pm.UndoChunk(): #pm.scriptEditorInfo(suppressInfo=True) selOrderTrackingEnabled = pm.selectPref(q=1, trackSelectionOrder=1) if not selOrderTrackingEnabled: #pm.confirmDialog( title='Warning', message='For pattern selection to work you need to enable selection order tracking [Windows > Settings/Preferences > Preferences > Selection > Track selection order]', button=['OK']) pm.selectPref(trackSelectionOrder=1) pm.mel.eval("selectPref -trackSelectionOrder true") return sel = pm.ls(orderedSelection=1,fl=1) if len(sel) <= 1: return # get name of mesh object containing selected components mesh = pm.ls(sel[0].name().split(".")[0])[0] ########## # VERTEX # ########## if sel[0].__class__.__name__ == "MeshVertex" and sel[1].__class__.__name__ == "MeshVertex": print "vepe" vertFirst = sel[-2].indices()[0] vertLast = sel[-1].indices()[0] # detect if two last selected vertices are next to each other nextToEachother = False pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1) pm.select( mesh+".vtx["+str(vertLast)+"]",add=1) pm.mel.eval("ConvertSelectionToContainedEdges;") if len(pm.ls(sl=1)) == 1: nextToEachother = True # restore selection order stack pm.mel.eval("ConvertSelectionToVertices;") # avoid getting stuck in edge/multi-component mode pm.select(sel,r=1) pm.select(sel[-1],d=1) pm.select(sel[-2],d=1) pm.select(sel[-2],add=1) pm.select(sel[-1],add=1) if nextToEachother: selectNextVertex("next") return # detect if two last selected vertices are on same edge loop pm.select( mesh+".vtx["+str(vertFirst)+"]",r=1) pm.select( mesh+".vtx["+str(vertLast)+"]",add=1) # converting two verts on the same loop to and edge loop # results in selecting all verts between them (why?) pm.mel.eval("SelectEdgeLoopSp;") path = pm.ls(sl=1,fl=1) if ( path ): # on same loop # get edge loop, needed for inversion later pm.mel.eval("ConvertSelectionToContainedEdges;") edgePath = pm.ls(sl=1,fl=1) # SelectEdgeRingSp is sometimes unreliable with multiple consecutive # edges selected so we use just one edge to find the current loop pm.select(edgePath[0],r=1) pm.mel.eval("SelectEdgeLoopSp;") loop = pm.ls(sl=1) # restore selection order stack pm.select(sel,r=1) pm.select(sel[-1],d=1) pm.select(sel[-2],d=1) pm.select(sel[-2],add=1) pm.select(sel[-1],add=1) if ( path ): # on same loop selectNextVertex("pattern", mesh, len(edgePath)-1, loop) ######## # EDGE # ######## if sel[0].__class__.__name__ == "MeshEdge" and sel[1].__class__.__name__ == "MeshEdge": edgeFirst = sel[-2].indices()[0] edgeLast = sel[-1].indices()[0] ring = pm.polySelect( mesh.name(), q=1, edgeRingPath=[edgeFirst,edgeLast] ) if ( ring ): if ( len(ring) == 2 ): selectNextEdge("ring") if ( len(ring) > 2 ): selectNextEdge("ringPattern", mesh, len(ring)-2) loop = pm.polySelect( mesh.name(), q=1, edgeLoopPath=[edgeFirst,edgeLast] ) if ( loop ): if (len(loop) == 2 ): selectNextEdge("loop") if ( len(loop) > 2 ): selectNextEdge("loopPattern", mesh, len(loop)-2) ######## # FACE # ######## if sel[0].__class__.__name__ == "MeshFace" and sel[1].__class__.__name__ == "MeshFace": faceFirst = sel[-2].indices()[0] faceLast = sel[-1].indices()[0] path = pm.polySelect( mesh.name(), q=1, shortestFacePath=[faceFirst,faceLast] ) if (path): if len(path) == 2: selectNextFace("next") if len(path) > 2: pm.select( mesh+".f["+str(faceFirst)+"]",r=1) pm.select( mesh+".f["+str(faceLast)+"]",add=1) pm.mel.eval("SelectEdgeLoopSp;") facePath = pm.ls(sl=1,fl=1) if (facePath): # face path isnt sorted pm.mel.eval("ConvertSelectionToContainedEdges;") pm.select(pm.ls(sl=1,fl=1)[0],r=1) pm.mel.eval("SelectEdgeRingSp;") pm.mel.eval("ConvertSelectionToVertices;") # TODO REM buggy command was: pm.mel.eval("GrowPolygonSelectionRegion;") pm.mel.eval("ConvertSelectionToContainedFaces;") loop = pm.ls(sl=1) print loop print "-------------------" # restore selection order stack pm.select(sel,r=1) pm.select(sel[-1],d=1) pm.select(sel[-2],d=1) pm.select(sel[-2],add=1) pm.select(sel[-1],add=1) #print len(facePath) if (facePath): selectNextFace("pattern", mesh, len(facePath)-2, loop)
def resetSelTrans(): with pm.UndoChunk(): for obj in pm.selected(): tra.resetTransform(obj)
def export_anim(root): # Select Root pymel.select(root) scene_name = str(pymel.sceneName().basename().split('.')[0]) path = os.path.join(siteCustomize.ROOT_DIR, 'animations', 'export', scene_name) path = path.replace('\\', '/') pymel.mel.eval('FBXResetExport()') pymel.mel.eval('FBXExportInAscii -v true') # EXPORT pymel.mel.eval('FBXExport -f "{0}" -s'.format(path)) if __name__ == '__main__': # # ctrl = pymel.selected()[0] # # export_pose(ctrl.region, pose_name='test') with pymel.UndoChunk(): main = pymel.PyNode('Main_Net') root = main.jnts[0] bake_anim(root) export_anim(root) pymel.undo()
def selectObj(model, object_names, mouse_button, key_modifier): """Select an object Args: model (PyNode): The rig top node object_names (list): The names of the objects to select mouse_button (QtSignal): Clicked mouse button signal key_modifier (QtSignal): Modifier button signal Returns: None """ if not model: return nameSpace = getNamespace(model) with pm.UndoChunk(): nodes = [] for name in object_names: if nameSpace: node = getNode(nameSpace + ":" + name) else: node = getNode(name) if not node: continue if not node and nameSpace: mgear.log("Can't find object : %s:%s" % (nameSpace, name), mgear.sev_error) elif not node: mgear.log("Can't find object : %s" % (name), mgear.sev_error) nodes.append(node) if not nodes: return if mouse_button == QtCore.Qt.RightButton: mirrorPose(False, nodes) return if mouse_button == QtCore.Qt.MiddleButton: mirrorPose(True, nodes) return # Key pressed if key_modifier is None: pm.select(nodes) elif key_modifier == QtCore.Qt.NoModifier: # No Key pm.select(nodes) elif key_modifier == QtCore.Qt.ControlModifier: # ctrl pm.select(nodes, deselect=True) elif key_modifier == QtCore.Qt.ShiftModifier: # shift pm.select(nodes, toggle=True) elif int(key_modifier) == (QtCore.Qt.ControlModifier | QtCore.Qt.ShiftModifier): # ctrl + shift pm.select(nodes, add=True) elif key_modifier == QtCore.Qt.AltModifier: # alt pm.select(nodes) elif int(key_modifier) == (QtCore.Qt.ControlModifier | QtCore.Qt.AltModifier): # ctrl + alt pm.select(nodes, deselect=True) elif int(key_modifier) == (QtCore.Qt.ShiftModifier | QtCore.Qt.AltModifier): # shift + alt pm.select(nodes, toggle=True) # Ctrl + alt + shift elif int(key_modifier) == (QtCore.Qt.ControlModifier | QtCore.Qt.AltModifier | QtCore.Qt.ShiftModifier): pm.select(nodes, add=True) else: pm.select(nodes)
def inner(*args, **kwargs): with pmc.UndoChunk(): result = func_(*args, **kwargs) return result
def resetSelTrans(): """Reset the transfom values (SRT) for the selected objects""" with pm.UndoChunk(): for obj in pm.selected(): transform.resetTransform(obj)