def doIt(self, args):
argData = OpenMaya.MArgDatabase(self.syntax(), args)
vector = OpenMaya.MVector(1.0, 0.0, 0.0)
if args.length() == 1:
vector.x = args.asDouble(0)
elif args.length == 2:
vector.x = args.asDouble(0)
vector.y = args.asDouble(1)
elif args.length == 3:
vector.x = args.asDouble(0)
vector.y = args.asDouble(1)
vector.y = args.asDouble(2)
self.__action(MoveToolCmd.kDoIt)
def doIt(self, args):
args_data = OpenMaya.MArgDatabase(self.syntax(), args)
type = None
select = None
repeat = False
directory = None
query = False
objects = None
match = False
clear = False
if args_data.isFlagSet(self.k_type[0]):
type = args_data.flagArgumentString(self.k_type[0], 0)
if args_data.isFlagSet(self.k_select[0]):
select = args_data.flagArgumentString(self.k_select[0], 0)
if args_data.isFlagSet(self.k_repeat[0]):
repeat = args_data.flagArgumentBool(self.k_repeat[0], 0)
if args_data.isFlagSet(self.k_directory[0]):
directory = args_data.flagArgumentString(self.k_directory[0], 0)
if args_data.isFlagSet(self.k_query[0]):
query = args_data.flagArgumentBool(self.k_query[0], 0)
if args_data.isFlagSet(self.k_objects[0]):
objects = args_data.flagArgumentString(self.k_objects[0], 0)
if args_data.isFlagSet(self.k_clear[0]):
clear = args_data.flagArgumentBool(self.k_clear[0], 0)
exim.execute(type, repeat, select, directory, query, objects, clear)
def doIt(self, argList):
try:
argData = OpenMaya.MArgDatabase(self.syntax(), argList)
except RuntimeError, inp:
OpenMaya.MGlobal.displayError(" ".join(
("Invalid Argument", str(inp))))
return
def doIt(self, argList):
argData = om.MArgDatabase(self.syntax(), argList)
# Check our flags
fileFlagSet = argData.isFlagSet(kTbSaveWeightsFileFlag)
actionFlagSet = argData.isFlagSet(kTbSaveWeightsActionFlag)
meshFlagSet = argData.isFlagSet(kTbSaveWeightsMeshFlag)
prettyPrintFlagSet = argData.isFlagSet(kTbSaveWeightsPrettyPrintFlag)
if fileFlagSet:
self.fileName = argData.flagArgumentString(kTbSaveWeightsFileFlag,
0)
else:
self.fileName = self.defaultFileName
if actionFlagSet:
self.action = argData.flagArgumentString(kTbSaveWeightsActionFlag,
0)
if meshFlagSet:
self.objectMesh = argData.flagArgumentString(
kTbSaveWeightsMeshFlag, 0)
if prettyPrintFlagSet:
self.prettyPrint = argData.flagArgumentString(
kTbSaveWeightsPrettyPrintFlag, 0)
else:
self.prettyPrint = False
self.main()
def parseArgs(self, args):
argData = OpenMaya.MArgDatabase(self.syntax(), args)
selObjects = OpenMaya.MSelectionList()
argData.getObjects(selObjects)
return selObjects
def doIt(self, *args):
argData = OpenMaya.MArgDatabase(self.syntax(), *args )
if argData.isFlagSet( SGAverageVertex.kWeightFlags[0] ):
self.__weight = argData.flagArgumentDouble(SGAverageVertex.kWeightFlags[0], 0 )
self.averageVerticesDoit()
self.redoIt()
def doIt(self, args):
modeArg = 0
fileName = ''
orderArg = 0
exclusiveArg = 0
# parse the arguments.
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(helpFlag):
self.setResult(helpText)
return ()
# read flag arguments
if argData.isFlagSet(modeFlag):
modeArg = argData.flagArgumentDouble(modeFlag, 0)
if argData.isFlagSet(orderFlag):
orderArg = argData.flagArgumentDouble(orderFlag, 0)
if argData.isFlagSet(exclusiveFlag):
exclusiveArg = argData.flagArgumentDouble(exclusiveFlag, 0)
if argData.isFlagSet(fileFlag):
fileName = argData.flagArgumentString(fileFlag, 0)
else:
OpenMaya.MGlobal.displayError(kPluginCmdName +
' needs file name flag.')
return ()
if fileName == '':
OpenMaya.MGlobal.displayError(kPluginCmdName +
' file name is not specified.')
return ()
if modeArg < 0 or modeArg > 1:
OpenMaya.MGlobal.displayError(
kPluginCmdName +
' mode needs to be set to either 0 for \'write\' or 1 for \'read\'.'
)
return ()
start = cmds.timerX()
msgString = ''
result = 0
if modeArg == 0:
result = self.writeWeights(fileName, exclusiveArg)
msgString = 'exported to '
else:
result = self.readWeights(fileName, orderArg)
msgString = 'imported from '
doneTime = cmds.timerX(startTime=start)
if result == 1:
OpenMaya.MGlobal.displayInfo(
'transferSkinCluster command took %.02f seconds' % doneTime)
OpenMaya.MGlobal.displayInfo('Weights ' + msgString + '\'' +
fileName + '\'')
def doIt(self, args):
'''
Main call: arguements passed back from the MSyntax/MArgDatabase
are object names as strings.
'''
Source = None
Destin = None
result = []
#Build the Arg List from the MSyntax/MArgDatabase
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(self.kSourceFlag):
Source = argData.flagArgumentString(self.kSourceFlag, 0)
if argData.isFlagSet(self.kDestinationFlag):
Destin = argData.flagArgumentString(self.kDestinationFlag, 0)
if argData.isFlagSet(self.kTransFlag):
self.snapTranslation = argData.flagArgumentBool(self.kTransFlag, 0)
if argData.isFlagSet(self.kRotsFlag):
self.snapRotation = argData.flagArgumentBool(self.kRotsFlag, 0)
#Make the api.MFnTransorm Nodes
self.MFntSource = self.__MFnTransformNode(Source)
self.MFntDestin = self.__MFnTransformNode(Destin)
if self.snapTranslation:
rotPivA = OpenMaya.MVector(
self.MFntSource.rotatePivot(OpenMaya.MSpace.kWorld))
rotPivB = OpenMaya.MVector(
self.MFntDestin.rotatePivot(OpenMaya.MSpace.kWorld))
self.origTrans = self.MFntDestin.getTranslation(
OpenMaya.MSpace.kWorld)
#We subtract the destinations translation from it's rotPivot, before adding it
#to the source rotPiv. This compensates for offsets in the 2 nodes pivots
targetTrans = (rotPivA + (self.origTrans - rotPivB))
self.MFntDestin.setTranslation(targetTrans, OpenMaya.MSpace.kWorld)
result.append(targetTrans)
if self.snapRotation:
#Fill the Undo
self.origRots = OpenMaya.MQuaternion()
self.MFntDestin.getRotation(self.origRots, OpenMaya.MSpace.kWorld)
#Read the source Quaternions and copy to destination
Quat = OpenMaya.MQuaternion()
self.MFntSource.getRotation(Quat, OpenMaya.MSpace.kWorld)
self.MFntDestin.setRotation(Quat, OpenMaya.MSpace.kWorld)
result.append(Quat)
# @et the returns
OpenMayaMPx.MPxCommand.clearResult()
#Pass back the destination co-ordinates required
OpenMayaMPx.MPxCommand.setResult(result)
def doIt(self, args):
print "Hello World!"
type = 'biped'
count = 53
distance = 20
row = 5
column = 5
row_offset = 0
column_offset = 0
random = 0
args_data = OpenMaya.MArgDatabase(self.syntax(), args)
if args_data.isFlagSet(self.k_type[0]):
type = args_data.flagArgumentString(self.k_type[0], 0)
if args_data.isFlagSet(self.k_count[0]):
count = args_data.flagArgumentInt(self.k_count[0], 0)
if args_data.isFlagSet(self.k_distance[0]):
count = args_data.flagArgumentInt(self.k_distance[0], 0)
if args_data.isFlagSet(self.k_row[0]):
row = args_data.flagArgumentInt(self.k_row[0], 0)
if args_data.isFlagSet(self.k_column[0]):
column = args_data.flagArgumentInt(self.k_column[0], 0)
if args_data.isFlagSet(self.k_row_offset[0]):
row_offset = args_data.flagArgumentDouble(self.k_row_offset[0], 0)
if args_data.isFlagSet(self.k_column_offset[0]):
column_offset = args_data.flagArgumentDouble(self.k_column_offset[0], 0)
if args_data.isFlagSet(self.k_random[0]):
random = args_data.flagArgumentDouble(self.k_random[0], 0)
print 'row', row
print 'column', column
if args_data.isFlagSet(self.k_create[0]):
create = args_data.flagArgumentBool(self.k_create[0], 0)
crowd_setup = crowdSetup.Connect(
type=type,
count=count,
distance=distance,
row=row,
column=column,
rowOffset=row_offset,
columnOffset=column_offset,
random=random
)
crowd_setup.create()
def doIt(self, args):
'''
simple switch of the evalManager JUST to get it registered in the undo stack
'''
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(self.kModeFlag):
mode = argData.flagArgumentString(self.kModeFlag, 0)
cmds.evaluationManager(mode=mode)
sys.stdout.write("evalManager_switch.doIt : setting mode=%s\n" % mode)
OpenMayaMPx.MPxCommand.clearResult()
OpenMayaMPx.MPxCommand.setResult(self.undostate)
def doIt(self, args):
# Parse the arguments.
argData = OpenMaya.MArgDatabase(syntaxCreator(), args)
self.SOURCE = argData.commandArgumentString(0)
if argData.isFlagSet(kRotationFlag) is True:
self.ROTATION = argData.flagArgumentBool(kRotationFlag, 0)
if argData.isFlagSet(kInstanceFlag) is True:
self.InstanceFlag = argData.flagArgumentBool(kInstanceFlag, 0)
cmds.setToolTo(self.setupDragger())
def doIt(self, args):
modeArg = 0
fileName = ""
orderArg = 0
exclusiveArg = 0
# parse the arguments.
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(helpFlag):
self.setResult(helpText)
return ()
if argData.isFlagSet(modeFlag):
modeArg = argData.flagArgumentDouble(modeFlag, 0)
if argData.isFlagSet(orderFlag):
orderArg = argData.flagArgumentDouble(orderFlag, 0)
if argData.isFlagSet(exclusiveFlag):
exclusiveArg = argData.flagArgumentDouble(exclusiveFlag, 0)
if argData.isFlagSet(fileFlag):
fileName = argData.flagArgumentString(fileFlag, 0)
else:
OpenMaya.MGlobal.displayError(
"{} needs file name flag.".format(kPluginCmdName))
return ()
if fileName == "":
OpenMaya.MGlobal.displayError(
"{} file name is not specified.".format(kPluginCmdName))
return ()
if modeArg < 0 or modeArg > 1:
OpenMaya.MGlobal.displayError(
"{} mode needs to be set to either 0 for 'write' "
"or 1 for 'read'.".format(kPluginCmdName))
return ()
start = cmds.timerX()
if modeArg == 0:
result = self.writeWeights(fileName, exclusiveArg)
msgString = "exported to "
else:
result = self.readWeights(fileName, orderArg)
msgString = "imported from "
doneTime = cmds.timerX(startTime=start)
if result == 1:
OpenMaya.MGlobal.displayInfo(
"transferSkinCluster command took {:.2f} seconds".format(
doneTime))
OpenMaya.MGlobal.displayInfo("Weights {}: {}".format(
msgString, fileName))
def doIt(self,argList):
argData = OM.MArgDatabase(self.syntax(),argList)
nameMsg = "Hello Stranger"
if argData.isFlagSet(kNameFlag):
nameMsg = "Hello %s"%argData.flagArgumentString(kNameFlag, 0)
ageMsg = "I dont know your age"
if argData.isFlagSet(kAgeFlag):
ageMsg = "You are %s years old" % int(argData.flagArgumentDouble(kAgeFlag, 0))
print "\n",nameMsg
print ageMsg
def doIt(self, args):
"""
Parse arguments and then call doItQuery()
"""
# parse the arguments
try:
argData = om.MArgDatabase(
self.syntax(),
args) # if this fails, it will raise its own exception...
except:
pass # ...so we can just pass here
else:
# validate the provided selection list
sList = om.MSelectionList()
argData.getObjects(sList)
iter = om.MItSelectionList(sList, om.MFn.kTransform)
if iter.isDone(
) or not iter.itemType() == om.MItSelectionList.kDagSelectionItem:
selectionStrings = []
sList.getSelectionStrings(selectionStrings)
raise Exception('%s is not a valid transform node.\n' %
selectionStrings[0])
iter.getDagPath(self.__transformPath)
self.__transformFn.setObject(self.__transformPath)
# establish the parameters for computation
if argData.isFlagSet(AR_TransformCmd.kWorldSpaceFlag):
self.__space = om.MSpace.kWorld
# use the transform node's rotate order as the default value
rotation = om.MEulerRotation()
self.__transformFn.getRotation(rotation)
self.__rotateOrder = rotation.order
if argData.isFlagSet(AR_TransformCmd.kRotateOrderFlag):
rotateOrderStr = argData.flagArgumentString(
AR_TransformCmd.kRotateOrderFlag, 0)
try:
self.__rotateOrder = kRotateOrderMapping[
rotateOrderStr.lower()]
except:
self.displayWarning(
'%s is not a valid rotate order. Rotate order of %s is being used instead.'
% (rotateOrderStr,
self.__transformPath.partialPathName()))
# determine which flags are set and perform the query
self.__translationArg = argData.isFlagSet(
AR_TransformCmd.kTranslationFlag)
self.__rotationArg = argData.isFlagSet(
AR_TransformCmd.kRotationFlag)
self.__quaternionArg = argData.isFlagSet(
AR_TransformCmd.kQuaternionFlag)
self.doItQuery()
def parseArgs(self, args):
argData = OpenMaya.MArgDatabase(self.syntax(), args)
try:
self.baseGeo = argData.commandArgumentString(0)
self.targetGeo = argData.commandArgumentString(1)
except:
self.baseGeo = self.getArgFromSelection(0, argData)
self.targetGeo = self.getArgFromSelection(1, argData)
if argData.isFlagSet(SplitShape.numberOfDivisionShortFlag):
self.numOfDivision = argData.flagArgumentInt(
SplitShape.numberOfDivisionShortFlag, 0)
def doIt(self, argList):
# Read all the arg variables
try:
argData = om.MArgDatabase(self.syntax(), argList)
except RuntimeError:
return om.MStatus.kFailure
# Saftey procaution so users don't try anything stupid. Read
# the full documentation to the lock_n_hide script before
# proceeding.
if not argData.isFlagSet(I_KNOW_FLAG):
raise KeyError('This command is not meant to be called directly.')
if argData.isFlagSet('-attribute'):
attribute = argData.flagArgumentString('-attribute', 0)
else:
raise KeyError(
'An attribute must be specified with the -attribute flag.')
if argData.isFlagSet('-lock'):
self.lock = argData.flagArgumentInt('-lock', 0)
if argData.isFlagSet('-hide'):
self.hide = argData.flagArgumentInt('-hide', 0)
# Initialize selection from stored argData
selection = om.MSelectionList()
argData.getObjects(selection)
# Reset saved plugs
self.plugs = []
# Find plugs
for x in range(selection.length()):
# Get depend node from selectionList
depend = om.MObject()
selection.getDependNode(x, depend)
depend = om.MFnDependencyNode(depend)
# Find plug. Probably needs some wrapper around findPlug if
# it fails.
try:
plug = depend.findPlug(attribute, 0)
except RuntimeError:
raise AttributeError('%s is not an attribute on %s' %
(attribute, depend.name()))
self.plugs.append(plug)
return self.redoIt()
def doIt(self, args):
deg = 3
ncvs = 20
spans = ncvs - deg
nknots = spans + 2 * deg - 1
radius = 4.0
pitch = 0.5
# Parse the arguments.
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(kPitchFlag):
pitch = argData.flagArgumentDouble(kPitchFlag, 0)
if argData.isFlagSet(kRadiusFlag):
radius = argData.flagArgumentDouble(kRadiusFlag, 0)
controlVertices = OpenMaya.MPointArray()
knotSequences = OpenMaya.MDoubleArray()
# Set up cvs and knots for the helix
#
for i in range(0, ncvs):
controlVertices.append(
OpenMaya.MPoint(radius * math.cos(i), pitch * i,
radius * math.sin(i)))
for i in range(0, nknots):
knotSequences.append(i)
# Now create the curve
#
curveFn = OpenMaya.MFnNurbsCurve()
nullObj = OpenMaya.MObject()
try:
# This plugin normally creates the curve by passing in the
# cv's. A function to create curves by passing in the ep's
# has been added. Set this to False to get that behaviour.
#
if True:
curveFn.create(controlVertices, knotSequences, deg,
OpenMaya.MFnNurbsCurve.kOpen, 0, 0, nullObj)
else:
curveFn.createWithEditPoints(controlVertices, 3,
OpenMaya.MFnNurbsCurve.kOpen,
False, False, False)
except:
sys.stderr.write("Error creating curve.\n")
raise
def argumentParser(self, argList):
syntax = self.syntax()
parsedArguments = OpenMaya.MArgDatabase(syntax, argList)
if parsedArguments.isFlagSet(kSparseFlag):
self.sparse = parsedArguments.flagArgumentDouble(kSparseFlag, 0)
if parsedArguments.isFlagSet(kSparseLongFlag):
self.SparseLong = parsedArguments.flagArgumentDouble(
kSparseLongFlag, 0)
if parsedArguments.isFlagSet(kSparseFlag):
self.setResult(helpMessage)
if parsedArguments.isFlagSet(kSparseLongFlag):
self.setResult(helpMessage)
def doIt(self, args):
# get the skinCluster for selected mesh
self.getSkinCluster()
if not self.fnSkin:
om.MGlobal.displayError("Select a meshs transform with skinCluster.")
return
argData = om.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(kIndexFlag):
self.index = argData.flagArgumentInt(kIndexFlag, 0)
if argData.isFlagSet(kValueFlag):
self.value = argData.flagArgumentDouble(kValueFlag, 0)
self.redoIt()
def doIt(self, args):
# Parse the arguments.
argData = OpenMaya.MArgDatabase(self.syntax(), args)
try:
self.cmdArg = argData.commandArgumentString(0)
except RuntimeError:
pass
if argData.isFlagSet(kVerboseFlag):
self.verbose = argData.flagArgumentBool(kVerboseFlag, 0)
# Do something
print "Hello world"
self.undoIt
def doIt(self, args):
"""
This method is called from script when this command is called.
It should set up any class data necessary for redo/undo,
parse any given arguments, and then call redoIt.
"""
argData = OpenMaya.MArgDatabase(self.syntax(), args)
if argData.isFlagSet(kStartFlag):
self.__start = argData.flagArgumentInt(kStartFlag, 0)
if argData.isFlagSet(kEndFlag):
self.__end = argData.flagArgumentInt(kEndFlag, 0)
if argData.isFlagSet(kByFlag):
self.__by = argData.flagArgumentInt(kByFlag, 0)
self.redoIt()
def doIt(self, args):
setNode = self.__fDGMod.createNode(kNodeId)
self.__fDGMod.doIt()
# Populate the set with the selected items
argData = om.MArgDatabase(self.syntax(), args)
selectionList = om.MSelectionList()
argData.getObjects(selectionList)
if selectionList.length():
setFn = om.MFnSet(setNode)
setFn.addMembers(selectionList)
depNodeFn = om.MFnDependencyNode(setNode)
ompx.MPxCommand.setResult(depNodeFn.name())
def doIt(self, args):
""" Just do it! """
# Parse the arguments.
argData = OpenMaya.MArgDatabase(syntaxCreator(), args)
if argData.isFlagSet(kMultiplyFlag):
self.MULTIPLY = argData.flagArgumentDouble(kMultiplyFlag, 0)
if argData.isFlagSet(kInvertedDirectionFlag):
self.INVERTED = argData.flagArgumentBool(kInvertedDirectionFlag, 0)
if argData.isFlagSet(kRotateFlag):
self.ROTATION = argData.flagArgumentDouble(kRotateFlag, 0)
self.redoIt()
def parse_args(self, args):
""" parse command arguments """
mode_map = {0: 'random',
1: 'jitter',
2: 'poisson3d',
3: 'poisson2d'}
arg_data = om.MArgDatabase(self.syntax(), args)
if arg_data.isFlagSet(K_SAMPLET_TYPE_FLAG):
self.sample_type = arg_data.flagArgumentString(K_SAMPLET_TYPE_FLAG, 0)
if arg_data.isFlagSet(K_NUM_SAMPLES_FLAG):
self.num_samples = arg_data.flagArgumentInt(K_NUM_SAMPLES_FLAG, 0)
if arg_data.isFlagSet(K_CELL_SIZE_FLAG):
self.cell_size = arg_data.flagArgumentDouble(K_CELL_SIZE_FLAG, 0)
if arg_data.isFlagSet(K_MIN_DISTANCE_FLAG):
self.min_distance = arg_data.flagArgumentDouble(K_MIN_DISTANCE_FLAG, 0)
selection = om.MSelectionList()
arg_data.getObjects(selection)
if selection.length() == 1:
found = False
node = om.MObject()
selection.getDependNode(0, node)
if node.hasFn(om.MFn.kDependencyNode):
dg_fn = om.MFnDependencyNode(node)
if dg_fn.typeName() == 'sporeNode':
self.target = node
if not self.sample_type:
type_plug = dg_fn.findPlug('emitType')
self.sample_type = mode_map[type_plug.asShort()]
if not self.num_samples:
num_plug = dg_fn.findPlug('numSamples')
self.num_samples = num_plug.asInt()
if not self.cell_size:
cell_plug = dg_fn.findPlug('cellSize')
self.cell_size = num_plug.asDouble()
if not self.min_distance:
radius_plug = dg_fn.findPlug('minRadius')
self.cell_size = radius_plug.asDouble()
found = True
if not found:
raise RuntimeError('The sample command only works on sporeNodes')
def argumentParser(self, argList):
syntax = self.syntax()
try:
parsedArguments = OpenMaya.MArgDatabase(syntax, argList)
except:
print 'Incorrect Argument'
return OpenMaya.kUnknownParameter
if parsedArguments.isFlagSet(kSparseFlag):
self.sparse = parsedArguments.flagArgumentDouble(kSparseFlag, 0)
if parsedArguments.isFlagSet(kSparseLongFlag):
self.sparse = parsedArguments.flagArgumentDouble(
kSparseLongFlag, 0)
if parsedArguments.isFlagSet(kHelpFlag):
self.setResult(helpMessage)
if parsedArguments.isFlagSet(kHelpLongFlag):
self.setResult(helpMessage)
def doIt(self, argList):
argData = OpenMaya.MArgDatabase(self.syntax(), argList)
if argData.isFlagSet('-help'):
self.displayInfo(
"kikoUndoer should never be called directly. It's "
"used directly from Kiko to manage Maya undos.")
else:
if (MayaUndoHelper.anim_curve_change is None
or MayaUndoHelper.dg_modifier is None):
raise RuntimeError("Kiko critical error: could not set up "
"command.")
self._anim_curve_change = MayaUndoHelper.anim_curve_change
self._dg_modifier = MayaUndoHelper.dg_modifier
MayaUndoHelper.anim_curve_change = None
MayaUndoHelper.dg_modifier = None
def doIt(self, argList):
argData = om.MArgDatabase(self.syntax(), argList)
# Check our flags
fileFlagSet = argData.isFlagSet(kTbSaveWeightsFileFlag)
actionFlagSet = argData.isFlagSet(kTbSaveWeightsActionFlag)
if fileFlagSet:
self.fileName = argData.flagArgumentString(kTbSaveWeightsFileFlag,
0)
else:
self.fileName = self.defaultFileName
if actionFlagSet:
self._action = argData.flagArgumentString(kTbSaveWeightsActionFlag,
0)
self.main()
def parse_args(self, args):
""" parse args """
arg_data = om.MArgDatabase(self.syntax(), args)
if arg_data.isFlagSet(k_name_flag):
self.name = arg_data.getFlagArgument(k_name_flag, 0)
selection = om.MSelectionList()
arg_data.getObjects(selection)
# # check if we got at least on item
if selection.length() == 0:
self.logger.error('Spore Command failed: Nothing Selected')
return False
for i in xrange(selection.length()):
dag_path = om.MDagPath()
selection.getDagPath(i, dag_path)
# get target
if i == 0:
try:
dag_path.extendToShape()
except RuntimeError:
self.logger.error(
'Spore Command failed: Object has more than one shape')
return False
if dag_path.hasFn(om.MFn.kMesh):
self.target = dag_path.node()
else:
self.logger.error(
'Spore Command failed: Object is not of type kMesh')
return False
# get source
else:
self.source.append(dag_path.node())
return True
def argumentParser(self, argList):
syntax = self.syntax()
# Use MArgDatabase to parse the argList
parsedArguments = openmaya.MArgDatabase(syntax, argList)
if parsedArguments.isFlagSet(kSparseFlag):
self.sparse = parsedArguments.flagArgumentDouble(kSparseFlag, 0)
# return openmaya.MStatus.kSuccess
# https://help.autodesk.com/view/MAYAUL/2017/ENU/?guid=__files_Maya_Python_API_Using_the_Maya_Python_API_htm
if parsedArguments.isFlagSet(kSparseFlag_long):
self.sparse_long = parsedArguments.flagArgumentDouble(
kSparseFlag_long, 0)
# return openmaya.MStatus.kSuccess
if parsedArguments.isFlagSet(kHelpFlag):
# show help message
self.setResult(helpMessage)
# return openmaya.MStatus.kSuccess
if parsedArguments.isFlagSet(kHelpFlag_long):
self.setResult(helpMessage)
def doIt(self, args):
'''
The doIt function is required for creating a command.
'''
om.MGlobal.displayWarning("You code goes here")
# Parse the arguments.
argData = om.MArgDatabase(self.syntax(),
args) # Gets the argument data
if argData.isFlagSet(kFlagName): # Replace kFlagName
flagVal = argData.flagArgumentDouble(
kFlagName, 0) # Replace kFlagName leave 0 for each flag.
# flagVal will now include the value from the argument
print(flagVal)
'''
# Example
if argData.isFlagSet(kPitchFlag):
pitch = argData.flagArgumentDouble(kPitchFlag, 0)
'''
'''
