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()
