def parseArgs(self, args): argData = OpenMaya.MArgParser(self.syntax(), args) if (argData.isFlagSet('nt')): self.numTurbulence = argData.flagArgumentInt('nt', 0) if (argData.isFlagSet('dr')): self.dewRate = argData.flagArgumentInt('dr', 0) if (argData.isFlagSet('sr')): self.spumeRate = argData.flagArgumentInt('sr', 0) if (argData.isFlagSet('wr')): self.waterRate = argData.flagArgumentInt('wr', 0) if (argData.isFlagSet('f')): self.waterRate = argData.flagArgumentDouble('f', 0) if (argData.isFlagSet('tl')): self.turbulenceLow = argData.flagArgumentDouble('tl', 0) if (argData.isFlagSet('th')): self.turbulenceHigh = argData.flagArgumentDouble('th', 0) if (argData.isFlagSet('g')): self.gravity = argData.flagArgumentDouble('g', 0)
def doIt(self, args): """ Command execution. """ voxelSize = 1.0 knifeCount = [1, 1, 1] offset = [0.0, 0.0, 0.0] gapSize = 0.1 # Parse the argument first argData = OpenMaya.MArgParser(self.syntax(), args) if argData.isFlagSet("ox"): offset[0] = argData.flagArgumentDouble("ox", 0) mel.eval("print " + str(offset[0])) if argData.isFlagSet("oy"): offset[1] = argData.flagArgumentDouble("oy", 0) if argData.isFlagSet("oz"): offset[2] = argData.flagArgumentDouble("oz", 0) if argData.isFlagSet("kx"): knifeCount[0] = argData.flagArgumentInt("kx", 0) if argData.isFlagSet("ky"): knifeCount[1] = argData.flagArgumentInt("ky", 0) if argData.isFlagSet("kz"): knifeCount[2] = argData.flagArgumentInt("kz", 0) if argData.isFlagSet("vz"): voxelSize = argData.flagArgumentDouble("vz", 0) # Use the currently selected object as the source source = cmds.ls(sl=True) objName = self.voxelize(source, voxelSize, gapSize, knifeCount, offset) self.energy(objName=objName)
def doIt(self, args): #- Since all the command actions will be done in the redoIt() method, this #- method will only parse the arguments. redoIt() will not use arguments #- at all. argParser = OpenMaya.MArgParser (self.syntax(),args) numFlags = argParser.numberOfFlagsUsed() if(numFlags != 1): OpenMaya.MGlobal.displayError("Simple Plugs requires one flag argument and a DAG object must be selected") return None else: if(argParser.isFlagSet(ROTATEFLAG) | argParser.isFlagSet(ROTATELONGFLAG)): #- The user enters 1, 2, or 3 to indicate x, y, or z rotation axis flag =argParser.flagArgumentInt(ROTATEFLAG,0) if(flag == AXIS_X): self.axis = AXIS_X elif(flag == AXIS_Y): self.axis = AXIS_Y elif(flag == AXIS_Z): self.axis = AXIS_Z else: OpenMaya.MGlobal.displayError("Invalid axis rotation argument") return None return self.redoIt(args)
def argumentParser(self, argList): argData = om.MArgParser(self.syntax(), argList) if argData.isFlagSet(resetDeltaDeformerCmd.HELP_FLAG[0]): print self.__class__.__doc__ return None if argData.isFlagSet(resetDeltaDeformerCmd.HELP_FLAG[1]): print self.__class__.__doc__ return None else: try: self.baseGeo = argData.commandArgumentString(0) except RuntimeError: selList = om2.MGlobal.getActiveSelectionList() self.baseGeo = selList.getSelectionStrings(0)[0] try: self.targetGeo = argData.commandArgumentString(1) except RuntimeError: selList = om2.MGlobal.getActiveSelectionList() self.targetGeo = selList.getSelectionStrings(1)[0] if argData.isFlagSet(resetDeltaDeformerCmd.PERCENTAGE_FLAG[0]): self.percentage = argData.flagArgumentDouble( resetDeltaDeformerCmd.PERCENTAGE_FLAG[0], 0) else: self.percentage = 100.0 if argData.isFlagSet(resetDeltaDeformerCmd.PERCENTAGE_FLAG[1]): self.percentage = argData.flagArgumentDouble( resetDeltaDeformerCmd.PERCENTAGE_FLAG[1], 0) else: self.percentage = 100.0
def doIt(self, argList): argData = om.MArgParser(self.syntax(), argList) # Command Args classArgs = self.parseCommandArgs(argData) methodArgs = self.parseFlagArgs(argData) assert len(methodArgs), 'only one flag can be used at a time' methodName, args = methodArgs[0] inst = pyObj(*classArgs) attrType = self._flagInfo[methodName]['type'] if attrType is types.MethodType: res = getattr(inst, methodName)(*args) else: # property if argData.isQuery(): res = getattr(inst, methodName) elif argData.isEdit(): assert len( args ) == 1, "a flag derived from a property should only have one argument" res = setattr(inst, methodName, args[0]) else: raise SyntaxError, "properties must either be edited or queried" return self.setResult(res)
def doIt(self, argList): argData = om.MArgParser(self.syntax(), argList) cmdArgs = self.parseCommandArgs(argData) flagArgs = self.parseFlagArgs(argData) if not classWrap: # doing a function wrap... # unpack the flag arguments, there should always only be 1 kwargs = dict([(x[0], x[1][0]) for x in flagArgs]) res = pyObj(*cmdArgs, **kwargs) else: # doing a class wrap... if len(flagArgs) != 1: raise RuntimeError( 'only one flag can be used at a time for command %s' % commandName) longname, flagArgs = flagArgs[0] inst = pyObj(*cmdArgs) flagInfo = self._flagInfo[longname] attrType = flagInfo['type'] methodName = flagInfo['methodName'] # PY2: once python-3 only, can probably remove the # types.MethodType check if issubclass( attrType, (types.FunctionType, types.MethodType)): # method # build out the args and kwargs... # ...can't just pass flagArgs straight into our method using # myMethod(*flagArgs) # ...because we may have filtered out some optional args, so # the positional information isn't right... ndefaults = len(flagInfo['defaults']) args = flagArgs[:-ndefaults] defaultNames = flagInfo['argNames'][-ndefaults:] defaultVals = flagArgs[-ndefaults:] kwargs = dict(list(zip(defaultNames, defaultVals))) res = getattr(inst, methodName)(*args, **kwargs) else: # property if argData.isQuery(): res = getattr(inst, methodName) elif argData.isEdit(): # property-defined flags can only take one arg if len(flagArgs) != 1: raise RuntimeError( 'flag %s for command %s may only have one arg' % (longname, commandName)) res = setattr(inst, methodName, flagArgs[0]) else: raise SyntaxError( "properties must either be edited or queried") return self.setResult(res)
def parseArguments(self, args): argData = OpenMaya.MArgParser(self.syntax(), args) filepath = cmds.file(q=True, sn=True) filename = os.path.basename(filepath) output, extension = os.path.splitext(filename) if argData.isFlagSet(kShortOutputFlagName): output = argData.flagArgumentString(kShortOutputFlagName, 0) return output
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) if argData.isFlagSet(kAnimLibraryFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryFlagXrig, 0) self._xrig = xrig_context(self._context) elif argData.isFlagSet(kAnimLibraryLongFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryLongFlagXrig, 0) self._xrig = xrig_context(self._context) else: raise Exception('-x (-xrig) flag needed.')
def parseArgs(self, args): argData = OpenMaya.MArgParser(self.syntax(), args) if (argData.isFlagSet('np')): self.numParticles = argData.flagArgumentInt('np', 0) if (argData.isFlagSet('dim')): self.size_x = argData.flagArgumentDouble('dim', 0) self.size_y = argData.flagArgumentDouble('dim', 1) self.size_z = argData.flagArgumentDouble('dim', 2)
def args(self, args): """ Parse arguments and return an MArgParser. If the arguments aren't valid, return None. Maya will have printed an error, so we should just stop if that happens. """ try: return om.MArgParser(self.syntax(), args) except RuntimeError: return None
def parseArguments(self, args): argData = om.MArgParser(self.syntax(), args) # Drag point self.flagValue = [] self.flagValue.append(argData.flagArgumentDouble(kDragPointF, 0)) self.flagValue.append(argData.flagArgumentDouble(kDragPointF, 1)) self.flagValue.append(argData.flagArgumentDouble(kDragPointF, 2)) # Live Object self.obj = argData.commandArgumentString(0)
def doIt(self, argList): sysPrint("\n########") for i in range(argList.length()): sysPrint("argList: %s" % argList.asString(i)) try: argParser = OpenMaya.MArgParser(self.syntax(), argList) except Exception, e: sysPrint("Error parsing syntax") raise AttributeError("Wrong argument call: %s" % str(e))
def doIt(self, args): # arguments argData = om.MArgParser(self.syntax(), args) index = argData.flagArgumentInt(kFroIndexF, 0) #currently selected vertex (index) range = argData.flagArgumentDouble(kFroRangeF, 0) #max distance to find a vertex # get the active selection sel = om.MSelectionList() om.MGlobal.getActiveSelectionList( sel ) list = om.MItSelectionList(sel, om.MFn.kMesh) # get mesh mesh = None dagPath = om.MDagPath() list.getDagPath( dagPath ) mesh = om.MFnMesh( dagPath ) #define variables to find the vertex nb = mesh.numVertices() point = om.MPoint() #target point foundVtx = 0 closestVert = 0 minLength = None pos = om.MPoint() mesh.getPoint(index, pos, om.MSpace.kWorld) # search for the nearest vertex count = 0 while count < nb : # ignore vertex already selected by user if count != index : #get point by its index mesh.getPoint(count, point, om.MSpace.kWorld) dist = pos.distanceTo( point ) #if the vtx is the closest, save it (only if we are under the user range) if dist <= range : if minLength is None or dist < minLength: foundVtx = 1 minLength = dist closestVert = count count += 1 #send the closest vertex to the user resultArray = om.MDoubleArray() resultArray.append( foundVtx ) resultArray.append( closestVert ) self.clearResult() self.setResult( resultArray )
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) if argData.isFlagSet(kAnimLibraryFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryFlagTravelMode, 0) elif argData.isFlagSet(kAnimLibraryLongFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryLongFlagTravelMode, 0) else: self.travel_mode = 'SELECTED' if argData.isFlagSet(kAnimLibraryFlagChannelBox): self._channel = argData.flagArgumentBool(kAnimLibraryFlagChannelBox, 0) elif argData.isFlagSet(kAnimLibraryLongFlagChannelBox): self._channel = argData.flagArgumentBool(kAnimLibraryLongFlagChannelBox, 0) else: self._channel = False if argData.isFlagSet(kAnimLibraryFlagXmlFile): self._file = argData.flagArgumentString(kAnimLibraryFlagXmlFile, 0) elif argData.isFlagSet(kAnimLibraryLongFlagXmlFile): self._file = argData.flagArgumentString(kAnimLibraryLongFlagXmlFile, 0) else: raise Exception('-f (-file) flag needed.') if argData.isFlagSet(kAnimLibraryFlagNamespace): self._namespace = argData.flagArgumentString(kAnimLibraryFlagNamespace, 0) elif argData.isFlagSet(kAnimLibraryLongFlagNamespace): self._namespace = argData.flagArgumentString(kAnimLibraryLongFlagNamespace, 0) else: self._namespace = None if argData.isFlagSet(kAnimLibraryFlagApplyMode): self.apply_mode = argData.flagArgumentString(kAnimLibraryFlagApplyMode, 0) elif argData.isFlagSet(kAnimLibraryLongFlagApplyMode): self.apply_mode = argData.flagArgumentString(kAnimLibraryLongFlagApplyMode, 0) else: self.apply_mode = 'BLEND' if argData.isFlagSet(kAnimLibraryFlagModify): self._modify = argData.flagArgumentString(kAnimLibraryFlagModify, 0) elif argData.isFlagSet(kAnimLibraryLongFlagModify): self._modify = argData.flagArgumentString(kAnimLibraryLongFlagModify, 0) else: self._modify = None if argData.isFlagSet(kAnimLibraryFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryFlagXrig, 0) self._xrig = xrig_context(self._context) elif argData.isFlagSet(kAnimLibraryLongFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryLongFlagXrig, 0) self._xrig = xrig_context(self._context) else: raise Exception('-x (-xrig) flag needed.')
def doIt(self, argList): argData = om.MArgParser(self.syntax(), argList) # Command Args args = self.parseCommandArgs(argData) # unpack the flag arguments, there should always only be 1 kwargs = dict([(x[0], x[1][0]) for x in self.parseFlagArgs(argData)]) res = pyObj(*args, **kwargs) return self.setResult(res)
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) if argData.isFlagSet(kAnimLibraryFlagXmlFile): self.file = argData.flagArgumentString(kAnimLibraryFlagXmlFile, 0) elif argData.isFlagSet(kAnimLibraryLongFlagXmlFile): self.file = argData.flagArgumentString(kAnimLibraryLongFlagXmlFile, 0) else: raise Exception('-f (-file) flag needed.') if argData.isFlagSet(kAnimLibraryFlagNamespace): self.namespace = argData.flagArgumentString(kAnimLibraryFlagNamespace, 0) elif argData.isFlagSet(kAnimLibraryLongFlagNamespace): self.namespace = argData.flagArgumentString(kAnimLibraryLongFlagNamespace, 0) else: self.namespace = None
def parseArgs(self, args): #parse the command's arguments #create an argument parser object. argData = OpenMaya.MArgParser(self.syntax(), args) #check if each flag is set, and store its value. if argData.isFlagSet('np'): self.numParticles = argData.flagArgumentInt('np', 0) if argData.isFlagSet('dim'): self.size_x = argData.flagArgumentDouble('dim', 0) self.size_y = argData.flagArgumentDouble('dim', 1) self.size_z = argData.flagArgumentDouble('dim', 2) if argData.isFlagSet('sv'): self.volShapeNum = argData.flagArgumentInt('sv', 0)
def parseArguments(self, args): # The following MArgParser object allows you to check if specific flags are set. argData = OpenMaya.MArgParser(self.syntax(), args) inputName = "" inputID = "0" if argData.isFlagSet(kNameFlagShort): flagParam = argData.flagArgumentString(kNameFlagShort, 0) inputName = str(flagParam) if argData.isFlagSet(kIdFlagShort): flagParam = argData.flagArgumentInt(kIdFlagShort, 0) inputID = str(flagParam) return [inputName, inputID]
def parseArgs(self, pArguments): ''' Parses the command's arguments. ''' # Set the default chain length in case there are no arguments. global defaultLength self.length = defaultLength # Obtain the flag value, if the flag is set. argData = OpenMaya.MArgParser(self.syntax(), pArguments) if argData.isFlagSet(kLengthFlag): # Get the value associated with the flag as an integer. flagValue = argData.flagArgumentInt(kLengthFlag, 0) # Make sure this value is larger than the default length. if flagValue > defaultLength: self.length = flagValue
def doIt(self, args): argdb = om.MArgParser(self.syntax(), args) if argdb.isFlagSet(shelfFlag): # s = ['MOD', 'RIG', 'SDR', 'TRK', 'LAY', 'ANI', 'EFX', 'CFX', 'LGT', 'ENV'] shelfFlagTst = argdb.flagArgumentString(shelfFlag, 0) if shelfFlagTst == 'all': shelf_Scripts.create_shelf() elif shelfFlagTst == 'remove': shelf_Scripts.create_shelf(remove=1) else: shelf_Scripts.create_shelf(False, shelfFlagTst) if argdb.isFlagSet(projectFlag): project = argdb.flagArgumentString(projectFlag, 0) if not project: raise ValueError('No import project name!!!') else: startMaya.run(project)
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) if argData.isFlagSet(kAnimLibraryFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryFlagTravelMode, 0) elif argData.isFlagSet(kAnimLibraryLongFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryLongFlagTravelMode, 0) else: raise Exception('-m (-mode) flag needed.') if argData.isFlagSet(kAnimLibraryFlagChannelBox): self.channelBox = argData.flagArgumentBool(kAnimLibraryFlagChannelBox, 0) elif argData.isFlagSet(kAnimLibraryLongFlagChannelBox): self.channelBox = argData.flagArgumentBool(kAnimLibraryLongFlagChannelBox, 0) else: self.channelBox = False if argData.isFlagSet(kAnimLibraryFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryFlagXrig, 0) elif argData.isFlagSet(kAnimLibraryLongFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryLongFlagXrig, 0) else: raise Exception('-x (-xrig) flag needed.')
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) if argData.isFlagSet(kAnimLibraryFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryFlagTravelMode, 0) elif argData.isFlagSet(kAnimLibraryLongFlagTravelMode): self.travel_mode = argData.flagArgumentString(kAnimLibraryLongFlagTravelMode, 0) else: raise Exception('-m (-mode) flag needed.') if argData.isFlagSet(kAnimLibraryFlagNamespace): self.namespace = argData.flagArgumentString(kAnimLibraryFlagNamespace, 0) elif argData.isFlagSet(kAnimLibraryLongFlagNamespace): self.namespace = argData.flagArgumentString(kAnimLibraryLongFlagNamespace, 0) else: self.namespace = None if argData.isFlagSet(kAnimLibraryFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryFlagXrig, 0) elif argData.isFlagSet(kAnimLibraryLongFlagXrig): self._context = argData.flagArgumentString(kAnimLibraryLongFlagXrig, 0) else: self._context = None
def argumentParser(self, argList): argData = om.MArgParser(self.syntax(), argList) if argData.isFlagSet(resetDeltaCmd.kHelpFlag): print self.__class__.__doc__ return None if argData.isFlagSet(resetDeltaCmd.kHelpLongFlag): print self.__class__.__doc__ return None else: self.baseGeo = argData.commandArgumentString(0) try: self.targetGeo = argData.commandArgumentString(1) except RuntimeError: selList = om2.MGlobal.getActiveSelectionList() self.targetGeo = selList.getSelectionStrings(0)[0] if argData.isFlagSet(resetDeltaCmd.kPercentageFlag): self.percentage = argData.flagArgumentDouble( resetDeltaCmd.kPercentageFlag, 0) else: self.percentage = 1.0 if argData.isFlagSet(resetDeltaCmd.kPercentageLongFlag): self.percentage = argData.flagArgumentDouble( resetDeltaCmd.kPercentageLongFlag, 0) else: self.percentage = 1.0 if argData.isFlagSet(resetDeltaCmd.kAxisFlag): self.axis = "{}".format( argData.flagArgumentString(resetDeltaCmd.kAxisFlag, 0)) else: self.axis = 'xyz' if argData.isFlagSet(resetDeltaCmd.kAxisLongFlag): self.axis = "{}".format( argData.flagArgumentString(resetDeltaCmd.kAxisLongFlag, 0)) else: self.axis = 'xyz' if argData.isFlagSet(resetDeltaCmd.kPositiveFlag): self.positive = argData.flagArgumentBool( resetDeltaCmd.kPositiveFlag, 0) else: self.positive = False if argData.isFlagSet(resetDeltaCmd.kPositiveLongFlag): self.positive = argData.flagArgumentBool( resetDeltaCmd.kPositiveLongFlag, 0) else: self.positive = False if argData.isFlagSet(resetDeltaCmd.kWorldSpaceFlag): self.ws = argData.flagArgumentBool( resetDeltaCmd.kWorldSpaceFlag, 0) else: self.ws = False if argData.isFlagSet(resetDeltaCmd.kWorldSpaceLongFlag): self.ws = argData.flagArgumentBool( resetDeltaCmd.kWorldSpaceLongFlag, 0) else: self.ws = False
def parseArgs(self, kArguments): argData = OpenMaya.MArgParser(self.syntax(), kArguments) self.percent = argData.commandArgumentInt(0)
def doIt(self, args): parser = OpenMaya.MArgParser(self.syntax(), args) #(3) key = 'gobble' #(4) if parser.isFlagSet(wav_flag_short): key = parser.flagArgumentString(wav_flag_short, 0) playsound.play_sound(WAVS[key]) #(5)
def doIt(self, args): argParser = om.MArgParser(self.syntax(), args) nodeTypeName = argParser.commandArgumentString(0) print "creating node type: {}".format(nodeTypeName) createNode(nodeTypeName)
def doIt(self, args): '''Creates the node and connects everything based on the parameters given''' # get the arguments passed in argData = OpenMaya.MArgParser(self.syntax(), args) # get objects to use in the constraint and make sure there is only two objects = [] argData.getObjects(objects) if not objects: # use the selection objects = cmds.ls(sl=True) for obj in objects: self.sList.add(obj) # if there is less than two objects given, return an error if self.sList.length() < 2: raise RuntimeError( 'Two transforms are required to create constraint.') # get the target object path and make sure it's a transform type targetDAG = OpenMaya.MDagPath() try: self.sList.getDagPath(0, targetDAG) except RuntimeError: raise RuntimeError( 'Target object must be a DAG object type. Unable to get path to object.' ) targetTransFn = OpenMaya.MFnTransform() try: targetTransFn.setObject(targetDAG) except RuntimeError: raise RuntimeError( 'Target object type invalid. You must choose a transform.') # get the constraint object path and make sure it's a transform type constraintDAG = OpenMaya.MDagPath() try: self.sList.getDagPath(1, constraintDAG) except RuntimeError: raise RuntimeError( 'Constraint object must be a DAG object type. Unable to get path to object.' ) constrainedTransFn = OpenMaya.MFnTransform() try: constrainedTransFn.setObject(constraintDAG) except RuntimeError: raise RuntimeError( 'Constraint object type invalid. You must choose a transform.') numSkips = argData.numberOfFlagUses('-sk') if numSkips > 3: raise RuntimeError('You can not have more than 3 skip flags.') if argData.isFlagSet('-n'): self.nodeName = argData.flagArgumentString('-n', 0) for i in range(numSkips): argList = OpenMaya.MArgList() argData.getFlagArgumentList('-sk', i, argList) axis = argList.asString(0) if axis == 'x': self.skipX = True elif axis == 'y': self.skipY = True elif axis == 'z': self.skipZ = True # distance flag if argData.isFlagSet('-d'): self.distanceValue = argData.flagArgumentDouble('-d', 0) else: # calculate the distance targetPos = targetTransFn.getTranslation(OpenMaya.MSpace.kWorld) constrainedPos = constrainedTransFn.getTranslation( OpenMaya.MSpace.kWorld) localPos = targetPos - constrainedPos self.distanceValue = localPos.length() # start frame flag if argData.isFlagSet('-sf'): self.startFrame = argData.flagArgumentDouble('-sf', 0) else: self.startFrame = cmds.currentTime(q=True) # start position if argData.isFlagSet('-sp'): spX = argData.flagArgumentDouble('-sp', 0) spY = argData.flagArgumentDouble('-sp', 1) spZ = argData.flagArgumentDouble('-sp', 2) self.startVector = OpenMaya.MVector(spX, spY, spZ) else: self.startVector = constrainedTransFn.getTranslation( OpenMaya.MSpace.kTransform) self.redoIt()