MStatus CVData::readASCII ( const MArgList& args,
unsigned& lastParsedElement )
{
MStatus status;
_intData = args.asInt( lastParsedElement++, &status );
if ( status == MS::kSuccess ) {
_doubleData = args.asDouble( lastParsedElement++, &status );
}
return status;
}
MStatus fluidInfoCmd::parseArgs( const MArgList& args )
{
// Parse the arguments.
MStatus stat = MS::kSuccess;
// some defaults for the number of voxels we might want to print
requestedVoxels = -1;
if( args.length() < 1 )
{
MGlobal::displayError( "Missing fluid node name argument." );
return MS::kFailure;
}
else if( args.length() > 2 )
{
MGlobal::displayError( "Too many arguments." );
return MS::kFailure;
}
fluidName = args.asString( 0, &stat );
if (stat != MS::kSuccess)
{
MGlobal::displayError( "Failed to parse fluid node name argument." );
return MS::kFailure;
}
if(args.length() == 1) {
// assume that the user wants to print all the voxels
// they probably won't do this more than once
requestedVoxels = -1;
} else {
requestedVoxels = args.asInt( 1, &stat );
if (stat != MS::kSuccess)
{
MGlobal::displayError( "Failed to parse num voxels to pribt argument." );
return MS::kFailure;
}
}
nodeFromName( fluidName, fluidNode );
if( fluidNode.isNull() )
{
MGlobal::displayError( "There is no fluid node with the given name." );
return MS::kFailure;
}
if( ! fluidNode.hasFn( MFn::kFluid ) )
{
MGlobal::displayError( "The named node is not a fluid." );
return MS::kFailure;
}
return MS::kSuccess;
}
MStatus ParameterisedHolderModificationCmd::doIt( const MArgList &argList )
{
// get the node we're operating on
MSelectionList selection;
selection.add( argList.asString( 0 ) );
selection.getDependNode( 0, m_node );
if( m_node.isNull() )
{
return MS::kFailure;
}
MFnDependencyNode fnNode( m_node );
MPxNode *userNode = fnNode.userNode();
m_parameterisedHolder = dynamic_cast<ParameterisedHolderInterface *>( userNode );
if( !m_parameterisedHolder )
{
return MStatus::kFailure;
}
// if we're being asked to change class then store the details of the class we want to set
// and the one we're replacing
if( argList.length() == 4 )
{
std::string originalClassName;
std::string originalSearchPathEnvVar;
m_parameterisedHolder->getParameterised( &originalClassName, &m_originalClassVersion, &originalSearchPathEnvVar );
m_originalClassName = originalClassName.c_str();
m_originalSearchPathEnvVar = originalSearchPathEnvVar.c_str();
m_newClassName = argList.asString( 1 );
m_newClassVersion = argList.asInt( 2 );
m_newSearchPathEnvVar = argList.asString( 3 );
m_changingClass = true;
}
else if( argList.length() != 1 )
{
displayError( "ieParameterisedHolderSetParameterised : wrong number of arguments." );
return MS::kFailure;
}
// store the original and new values of everything. these are just passed in from
// the FnParameterisedHolder. in the case of changing the held class we won't have
// any new values.
m_originalValues = g_originalValue;
m_originalClasses = g_originalClasses;
m_newValues = g_newValue;
m_newClasses = g_newClasses;
g_originalValue = 0;
g_originalClasses = 0;
g_newValue = 0;
g_newClasses = 0;
// change the maya side class or monkey with the maya side class parameters as requested. then remember the new values
// of everything and which parameters are changing so we can push them in and out during undo and redo.
if( m_changingClass )
{
MStatus s = m_parameterisedHolder->setParameterised( m_newClassName.asChar(), m_newClassVersion, m_newSearchPathEnvVar.asChar() );
if ( !s )
{
return s;
}
m_newValues = m_parameterisedHolder->getParameterisedInterface()->parameters()->getValue()->copy();
storeParametersWithNewValues( m_originalValues.get(), m_newValues.get(), "" );
despatchSetParameterisedCallbacks();
}
else
{
storeParametersWithNewValues( m_originalValues.get(), m_newValues.get(), "" );
m_parameterisedHolder->updateParameterised();
setNodeValuesForParametersWithNewValues();
despatchClassSetCallbacks();
}
return MS::kSuccess;
}
MStatus testExCameraSetCmd::parseArgs( const MArgList& args)
//
// Parses the command line arguments.
//
{
MStatus status;
// Get the flags. If the create or help flags are used, return success and ignore the other flags.
createUsed = (args.flagIndex(kCreateFlag, kCreateFlagLong) != MArgList::kInvalidArgIndex);
editUsed = (args.flagIndex(kEditFlag, kEditFlagLong) != MArgList::kInvalidArgIndex);
queryUsed = (args.flagIndex(kQueryFlag, kQueryFlagLong) != MArgList::kInvalidArgIndex);
helpUsed = (args.flagIndex(kHelpFlag, kHelpFlagLong) != MArgList::kInvalidArgIndex);
numLayersUsed = (args.flagIndex(kNumLayersFlag, kNumLayersFlagLong) != MArgList::kInvalidArgIndex);
// If flags are used which require no other information, return now.
if (createUsed || helpUsed)
return MS::kSuccess;
unsigned int maxArg = args.length() - 1;
unsigned int activeIndex = args.flagIndex(kActiveFlag, kActiveFlagLong);
unsigned int appendCameraIndex = args.flagIndex(kAppendCameraFlag, kAppendCameraFlagLong);
unsigned int appendCameraAndSetIndex = args.flagIndex(kAppendCameraAndSetFlag, kAppendCameraAndSetFlagLong);
unsigned int cameraIndex = args.flagIndex(kCameraFlag, kCameraFlagLong);
unsigned int deleteLayerIndex = args.flagIndex(kDeleteLayerFlag, kDeleteLayerFlagLong);
unsigned int layerIndex = args.flagIndex(kLayerFlag, kLayerFlagLong);
unsigned int layerTypeIndex = args.flagIndex(kLayerTypeFlag, kLayerTypeFlagLong);
unsigned int setIndex = args.flagIndex(kSetFlag, kSetFlagLong);
activeUsed = (activeIndex != MArgList::kInvalidArgIndex);
appendCameraUsed = (appendCameraIndex != MArgList::kInvalidArgIndex);
appendCameraAndSetUsed = (appendCameraAndSetIndex != MArgList::kInvalidArgIndex);
cameraUsed = (cameraIndex != MArgList::kInvalidArgIndex);
deleteLayerUsed = (deleteLayerIndex != MArgList::kInvalidArgIndex);
layerUsed = (layerIndex != MArgList::kInvalidArgIndex);
layerTypeUsed = (layerTypeIndex != MArgList::kInvalidArgIndex);
setUsed = (setIndex != MArgList::kInvalidArgIndex);
// Process each flag.
bool maxArgUsed = false;
if (activeUsed)
{
if (editUsed)
{
activeVal = args.asBool((activeIndex+1), &status);
if (status != MS::kSuccess)
{
MGlobal::displayError("-active must be either true or false");
return status;
}
if ((layerTypeIndex+1) == maxArg)
maxArgUsed = true;
}
}
if (appendCameraUsed)
{
camName = args.asString((appendCameraIndex+1), &status);
if (status != MS::kSuccess)
{
MGlobal::displayError("-appendCamera must have a valid camera node specified");
return status;
}
if ((appendCameraIndex+1) == maxArg)
maxArgUsed = true;
}
if (appendCameraAndSetUsed)
{
camName = args.asString((appendCameraAndSetIndex+1));
setName = args.asString((appendCameraAndSetIndex+2));
if ((appendCameraAndSetIndex+2) == maxArg)
maxArgUsed = true;
}
if (cameraUsed)
{
if (editUsed)
{
camName = args.asString(cameraIndex+1);
if ((cameraIndex+1) == maxArg)
maxArgUsed = true;
}
}
if (deleteLayerUsed)
{
cameraLayer = args.asInt(deleteLayerIndex+1);
if ((deleteLayerIndex+1) == maxArg)
maxArgUsed = true;
}
if (layerUsed)
{
cameraLayer = args.asInt(layerIndex+1);
if ((layerIndex+1) == maxArg)
maxArgUsed = true;
}
if (layerTypeUsed)
{
if (editUsed)
{
layerTypeVal = args.asString(layerTypeIndex+1);
if ((layerTypeIndex+1) == maxArg)
maxArgUsed = true;
}
}
if (setUsed)
{
if (editUsed)
{
setName = args.asString(setIndex+1);
if ((setIndex+1) == maxArg)
maxArgUsed = true;
}
}
// If all of the arguments have been used, get the cameraSet node from the selection list.
// Otherwise, get it from the last argument.
if (maxArgUsed)
MGlobal::getActiveSelectionList(list);
else
list.add(args.asString(maxArg));
return MS::kSuccess;
}
/*
emits particles with color sampled from specified
shading node/shading engine
*/
MStatus sampleParticles::doIt( const MArgList& args )
{
unsigned int i;
bool shadow = 0;
bool reuse = 0;
for ( i = 0; i < args.length(); i++ )
if ( args.asString(i) == MString("-shadow") ||
args.asString(i) == MString("-s") )
shadow = 1;
else if ( args.asString(i) == MString("-reuse") ||
args.asString(i) == MString("-r") )
reuse = 1;
else
break;
if ( args.length() - i < 5 )
{
displayError( "Usage: sampleParticles [-shadow|-reuse] particleName <shadingEngine|shadingNode.plug> resX resY scale\n"
" Example: sampleParticles -shadow particle1 phong1SG 64 64 10;\n"
" Example: sampleParticles particle1 file1.outColor 128 128 5;\n" );
return MS::kFailure;
}
if ( reuse && !shadow ) // can only reuse if shadow is turned on
reuse = 0;
MString particleName = args.asString( i );
MString node = args.asString( i+1 );
int resX = args.asInt( i+2 );
int resY = args.asInt( i+3 );
double scale = args.asDouble( i+4 );
if ( scale <= 0.0 )
scale = 1.0;
MFloatArray uCoord, vCoord;
MFloatPointArray points;
MFloatVectorArray normals, tanUs, tanVs;
if ( resX <= 0 )
resX = 1;
if ( resY <= 0 )
resY = 1;
MString command( "emit -o " );
command += particleName;
char tmp[2048];
float stepU = (float) (1.0 / resX);
float stepV = (float) (1.0 / resY);
// stuff sample data by iterating over grid
// Y is set to arch along the X axis
int x, y;
for ( y = 0; y < resY; y++ )
for ( x = 0; x < resX; x++ )
{
uCoord.append( stepU * x );
vCoord.append( stepV * y );
float curY = (float) (sin( stepU * (x) * M_PI )*2.0);
MFloatPoint curPt(
(float) (stepU * x * scale),
curY,
(float) (stepV * y * scale ));
MFloatPoint uPt(
(float) (stepU * (x+1) * scale),
(float) (sin( stepU * (x+1) * M_PI )*2.0),
(float) (stepV * y * scale ));
MFloatPoint vPt(
(float) (stepU * (x) * scale),
curY,
(float) (stepV * (y+1) * scale ));
MFloatVector du, dv, n;
du = uPt-curPt;
dv = vPt-curPt;
n = dv^du; // normal is based on dU x dV
n = n.normal();
normals.append( n );
du.normal();
dv.normal();
tanUs.append( du );
tanVs.append( dv );
points.append( curPt );
}
// get current camera's world matrix
MDagPath cameraPath;
M3dView::active3dView().getCamera( cameraPath );
MMatrix mat = cameraPath.inclusiveMatrix();
MFloatMatrix cameraMat( mat.matrix );
MFloatVectorArray colors, transps;
if ( MS::kSuccess == MRenderUtil::sampleShadingNetwork(
node,
points.length(),
shadow,
reuse,
cameraMat,
&points,
&uCoord,
&vCoord,
&normals,
&points,
&tanUs,
&tanVs,
NULL, // don't need filterSize
colors,
transps ) )
{
fprintf( stderr, "%u points sampled...\n", points.length() );
for ( i = 0; i < uCoord.length(); i++ )
{
sprintf( tmp, " -pos %g %g %g -at velocity -vv %g %g %g -at rgbPP -vv %g %g %g",
points[i].x,
points[i].y,
points[i].z,
normals[i].x,
normals[i].y,
normals[i].z,
colors[i].x,
colors[i].y,
colors[i].z );
command += MString( tmp );
// execute emit command once every 512 samples
if ( i % 512 == 0 )
{
fprintf( stderr, "%u...\n", i );
MGlobal::executeCommand( command, false, false );
command = MString( "emit -o " );
command += particleName;
}
}
if ( i % 512 )
MGlobal::executeCommand( command, true, true );
}
else
{
displayError( node + MString(" is not a shading engine! Specify node.attr or shading group node." ) );
}
return MS::kSuccess;
}
MStatus meshOp::doIt( const MArgList& argList )
//
// Description:
// implements the MEL meshOp command.
//
// Arguments:
// argList - the argument list that was passes to the command from MEL
//
// Return Value:
// MS::kSuccess - command succeeded
// MS::kFailure - command failed (returning this value will cause the
// MEL script that is being run to terminate unless the
// error is caught using a "catch" statement.
//
{
MStatus status;
bool badArgument = false;
// Only one parameter is expected to be passed to this command: the mesh
// operation type. Get it, validate it or stop prematurely
//
if (argList.length() == 1)
{
int operationTypeArgument = argList.asInt(0);
if (operationTypeArgument < 0
|| operationTypeArgument > kMeshOperationCount - 1)
{
badArgument = true;
}
else
{
fOperation = (MeshOperation)operationTypeArgument;
}
}
else badArgument = true;
if (badArgument)
{
cerr << "Expecting one parameter: the operation type." << endl;
cerr << "Valid types are: " << endl;
cerr << " 0 - Subdivide edge(s)." << endl;
cerr << " 1 - Subdivide face(s)." << endl;
cerr << " 2 - Extrude edge(s)." << endl;
cerr << " 3 - Extrude face(s)." << endl;
cerr << " 4 - Collapse edge(s)." << endl;
cerr << " 5 - Collapse face(s)." << endl;
cerr << " 6 - Duplicate face(s)." << endl;
cerr << " 7 - Extract face(s)." << endl;
cerr << " 8 - Split face(s)." << endl;
cerr << " 8 - Chamfer vertex(s)." << endl;
displayError(" Expecting one parameter: the operation type.");
return MS::kFailure;
}
// Each mesh operation only supports one type of components
//
MFn::Type componentType = meshOpFty::getExpectedComponentType(fOperation);
// Parse the selection list for selected components of the right type.
// To simplify things, we only take the first object that we find with
// selected components and operate on that object alone.
//
// All other objects are ignored and return warning messages indicating
// this limitation.
//
MSelectionList selList;
MGlobal::getActiveSelectionList( selList );
MItSelectionList selListIter( selList );
selListIter.setFilter( MFn::kMesh );
// The meshOperation node only accepts a component list input, so we build
// a component list using MFnComponentListData.
//
// MIntArrays could also be passed into the node to represent the ids,
// but are less storage efficient than component lists, since consecutive
// components are bundled into a single entry in component lists.
//
MFnComponentListData compListFn;
compListFn.create();
bool found = false;
bool foundMultiple = false;
for( ; !selListIter.isDone(); selListIter.next() )
{
MDagPath dagPath;
MObject component;
selListIter.getDagPath( dagPath, component );
// Check for selected components of the right type
//
if( component.apiType() == componentType )
{
if( !found )
{
// The variable 'component' holds all selected components
// on the selected object, thus only a single call to
// MFnComponentListData::add() is needed to store the selected
// components for a given object.
//
compListFn.add( component );
// Copy the component list created by MFnComponentListData
// into our local component list MObject member.
//
fComponentList = compListFn.object();
// Locally store the actual ids of the selected components so
// that this command can directly modify the mesh in the case
// when there is no history and history is turned off.
//
MFnSingleIndexedComponent compFn( component );
// Ensure that this DAG path will point to the shape
// of our object. Set the DAG path for the polyModifierCmd.
//
dagPath.extendToShape();
setMeshNode( dagPath );
found = true;
}
else
{
// Break once we have found a multiple object holding
// selected components, since we are not interested in how
// many multiple objects there are, only the fact that there
// are multiple objects.
//
foundMultiple = true;
break;
}
}
}
if( foundMultiple )
{
displayWarning("Found more than one object with selected components.");
displayWarning("Only operating on first found object.");
}
// Initialize the polyModifierCmd node type - mesh node already set
//
setModifierNodeType( meshOpNode::id );
if( found )
{
// Now, pass control over to the polyModifierCmd::doModifyPoly() method
// to handle the operation.
//
status = doModifyPoly();
if( status == MS::kSuccess )
{
setResult( "meshOp command succeeded!" );
}
else
{
displayError( "meshOp command failed!" );
}
}
else
{
displayError(
"meshOp command failed: Unable to find selected components" );
status = MS::kFailure;
}
return status;
}
void ParamList::parseArgs(const MArgList &args)
{
MStatus stat;
// Parse arguments from command line
for (unsigned int i = 0; i < args.length(); i++ )
{
if ((MString("-all") == args.asString(i,&stat)) && (MS::kSuccess == stat))
exportAll = true;
else if ((MString("-world") == args.asString(i,&stat)) && (MS::kSuccess == stat))
exportWorldCoords = true;
else if ((MString("-mesh") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportMesh = true;
meshFilename = args.asString(++i,&stat);
}
else if ((MString("-mat") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportMaterial = true;
materialFilename = args.asString(++i,&stat);
}
else if ((MString("-matPrefix") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
matPrefix = args.asString(++i,&stat);
}
else if ((MString("-copyTex") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
copyTextures = true;
texOutputDir = args.asString(++i,&stat);
}
else if ((MString("-lightOff") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
lightingOff = true;
}
else if ((MString("-skel") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportSkeleton = true;
skeletonFilename = args.asString(++i,&stat);
}
else if ((MString("-anims") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportAnims = true;
}
else if ((MString("-animCur") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportAnimCurves = true;
animFilename = args.asString(++i,&stat);
}
else if ((MString("-cam") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportCameras = true;
camerasFilename = args.asString(++i,&stat);
}
else if ((MString("-v") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportVBA = true;
}
else if ((MString("-n") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportVertNorm = true;
}
else if ((MString("-c") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportVertCol = true;
}
else if ((MString("-cw") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportVertCol = true;
exportVertColWhite = true;
}
else if ((MString("-t") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportTexCoord = true;
}
else if ((MString("-camAnim") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportCamerasAnim = true;
}
else if ((MString("-meshbin") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportMeshBin = true;
}
else if ((MString("-skelbin") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportSkelBin = true;
}
else if ((MString("-particles") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
exportParticles = true;
particlesFilename = args.asString(++i,&stat);
}
else if ((MString("-shared") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
useSharedGeom = true;
}
else if ((MString("-np") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
MString npType = args.asString(i,&stat);
if (npType == "curFrame")
neutralPoseType = NPT_CURFRAME;
else if (npType == "bindPose")
neutralPoseType = NPT_BINDPOSE;
else if (npType == "frame")
{
neutralPoseType = NPT_FRAME;
neutralPoseFrame = args.asInt(++i,&stat);
}
}
else if ((MString("-clip") == args.asString(i,&stat)) && (MS::kSuccess == stat))
{
//get clip name
MString clipName = args.asString(++i,&stat);
//get clip range
MString clipRangeType = args.asString(++i,&stat);
double startTime, stopTime;
if (clipRangeType == "startEnd")
{
startTime = args.asDouble(++i,&stat);
stopTime = args.asDouble(++i,&stat);
MString rangeUnits = args.asString(++i,&stat);
if (rangeUnits == "frames")
{
//range specified in frames => convert to seconds
MTime t1(startTime, MTime::uiUnit());
MTime t2(stopTime, MTime::uiUnit());
startTime = t1.as(MTime::kSeconds);
stopTime = t2.as(MTime::kSeconds);
}
}
else
{
//range specified by time slider
MTime t1 = MAnimControl::minTime();
MTime t2 = MAnimControl::maxTime();
startTime = t1.as(MTime::kSeconds);
stopTime = t2.as(MTime::kSeconds);
}
// get sample rate
double rate;
MString sampleRateType = args.asString(++i,&stat);
if (sampleRateType == "sampleByFrames")
{
// rate specified in frames
int intRate = args.asInt(++i,&stat);
MTime t = MTime(intRate, MTime::uiUnit());
rate = t.as(MTime::kSeconds);
}
else
{
// rate specified in seconds
rate = args.asDouble(++i,&stat);
}
//add clip info
clipInfo clip;
clip.name = clipName;
clip.start = startTime;
clip.stop = stopTime;
clip.rate = rate;
clipList.push_back(clip);
std::cout << "clip " << clipName.asChar() << "\n";
std::cout << "start: " << startTime << ", stop: " << stopTime << "\n";
std::cout << "rate: " << rate << "\n";
std::cout << "-----------------\n";
}
}
/* // Read options from exporter window
// Gather clips data
// Read info about the clips we have to transform
int numClips,exportClip,rangeType,rateType,rangeUnits;
double startTime,stopTime,rate;
MString clipName;
//read number of clips
MGlobal::executeCommand("eval \"$numClips+=0\"",numClips,false);
//read clips data
for (int i=1; i<=numClips; i++)
{
MString command = "checkBox -q -v ExportClip";
command += i;
MGlobal::executeCommand(command,exportClip,false);
if (exportClip)
{
//get clip name
command = "textField -q -tx ClipName";
command += i;
MGlobal::executeCommand(command,clipName,false);
//get clip range
command = "radioButtonGrp -q -sl ClipRangeRadio";
command += i;
MGlobal::executeCommand(command,rangeType,false);
if (rangeType == 1)
{ //range specified from user
command = "floatField -q -v ClipRangeStart";
command += i;
MGlobal::executeCommand(command,startTime,false);
command = "floatField -q -v ClipRangeEnd";
command += i;
MGlobal::executeCommand(command,stopTime,false);
//get range units
command = "radioButtonGrp -q -sl ClipRangeUnits";
command += i;
MGlobal::executeCommand(command,rangeUnits,false);
if (rangeUnits == 1)
{ //range specified in frames => convert to seconds
MTime t1(startTime, MTime::uiUnit());
MTime t2(stopTime, MTime::uiUnit());
startTime = t1.as(MTime::kSeconds);
stopTime = t2.as(MTime::kSeconds);
}
}
else
{ //range specified by time slider
MTime t1 = MAnimControl::minTime();
MTime t2 = MAnimControl::maxTime();
startTime = t1.as(MTime::kSeconds);
stopTime = t2.as(MTime::kSeconds);
}
//get sample rate
command = "radioButtonGrp -q -sl ClipRateType";
command += i;
MGlobal::executeCommand(command,rateType,false);
MTime t;
switch (rateType)
{
case 1: //rate specified in frames
command = "intField -q -v ClipRateFrames";
command += i;
MGlobal::executeCommand(command,rate,false);
t = MTime(rate, MTime::uiUnit());
rate = t.as(MTime::kSeconds);
break;
case 2: //rate specified in seconds
command = "floatField -q -v ClipRateSeconds";
command += i;
MGlobal::executeCommand(command,rate,false);
break;
default://rate not specified, get from time slider
rate = -1;
break;
}
//add clip info
clipInfo clip;
clip.name = clipName;
clip.start = startTime;
clip.stop = stopTime;
clip.rate = rate;
clipList.push_back(clip);
std::cout << "clip " << clipName.asChar() << "\n";
std::cout << "start: " << startTime << ", stop: " << stopTime << "\n";
std::cout << "rate: " << rate << "\n";
std::cout << "-----------------\n";
}
}*/
}
MStatus pointOnMeshCommand::doIt(const MArgList& args)
{
// INITIALIZE PRIVATE DATA FOR THE COMMAND:
nodeCreated = positionSpecified = normalSpecified = faceIndexSpecified = relativeSpecified = parameterUSpecified = parameterVSpecified = false;
meshNodeName = pointOnMeshInfoName = "";
// PARSE THE COMMAND'S ARGUMENTS:
for (unsigned i=0; i<args.length(); i++)
{
if ((MString("-name")==args.asString(i)) || (MString("-na")==args.asString(i)))
pointOnMeshInfoName = args.asString(++i);
else if ((MString("-position")==args.asString(i)) || (MString("-p")==args.asString(i)))
positionSpecified = true;
else if ((MString("-normal")==args.asString(i)) || (MString("-nr")==args.asString(i)))
normalSpecified = true;
else if ((MString("-faceIndex")==args.asString(i)) || (MString("-f")==args.asString(i)))
{
faceIndexSpecified = true;
int temp = args.asInt(++i);
if (temp<0)
{
displayError("Invalid faceIndex!");
return MS::kFailure;
}
faceIndex = temp;
}
else if ((MString("-relative")==args.asString(i)) || (MString("-r")==args.asString(i)))
{
relativeSpecified = true;
relative = args.asBool(++i);
}
else if ((MString("-parameterU")==args.asString(i)) || (MString("-u")==args.asString(i)))
{
parameterUSpecified = true;
double temp = args.asDouble(++i);
if ((temp<0) || (temp>1))
{
displayError("Invalid parameterU!");
return MS::kFailure;
}
parameterU = temp;
}
else if ((MString("-parameterV")==args.asString(i)) || (MString("-v")==args.asString(i)))
{
parameterVSpecified = true;
double temp = args.asDouble(++i);
if ((temp<0) || (temp>1))
{
displayError("Invalid parameterV!");
return MS::kFailure;
}
parameterV = temp;
}
else if (i==(args.length()-1))
meshNodeName = args.asString(i);
else
{
MString errorMessage = "Invalid flag: ";
errorMessage += args.asString(i);
displayError(errorMessage);
return MS::kFailure;
}
}
// MAKE SURE UNSPECIFIED INPUT PARAMETER FLAGS GET DEFAULT VALUES:
if (!faceIndexSpecified)
faceIndex = 0;
if (!relativeSpecified)
relative = true;
if (!parameterUSpecified)
parameterU = 0.5;
if (!parameterVSpecified)
parameterV = 0.5;
// DO THE WORK:
return redoIt();
}