MStatus AlembicProfileBeginCommand::doIt(const MArgList& args) {
MStatus status = MS::kSuccess;
#ifdef ESS_PROFILING
MArgParser argData(syntax(), args, &status);
if(!argData.isFlagSet("fileNameArg"))
{
// TODO: display dialog
MGlobal::displayError("[ExocortexAlembic] No fileName specified.");
return status;
}
// get the filename arg
MString fileName = argData.flagArgumentString("fileNameArg",0);
std::string strFileName( fileName.asChar() );
if( nameToProfiler.find( strFileName ) == nameToProfiler.end() ) {
boost::shared_ptr<Profiler> profiler( new Profiler( strFileName.c_str() ) );
nameToProfiler.insert( std::pair<std::string, boost::shared_ptr<Profiler>>( strFileName, profiler ) );
}
else {
nameToProfiler[ strFileName]->resume();
}
#endif
return status;
}
MStatus linearFrictionCmd::doIt(const MArgList& args)
{
MStatus stat;
MArgDatabase argData(syntax(),args,&stat);
if(argData.isFlagSet(lfFlag))argData.getFlagArgument(lfFlag,0,linearFriction);
MSelectionList activeSelect;
MGlobal::getActiveSelectionList(activeSelect);
for(int i=0;i<activeSelect.length();i++)
{
MObject tNode;
activeSelect.getDependNode(i,tNode);
MFnDagNode fnDagNode(tNode);
MObject pNode=fnDagNode.child(0);
MFnDependencyNode fnNode(pNode);
//MString name=fnNode1.name().asChar();
if(fnNode.typeId() == particleNode::typeId)
{
//get solver message attribute from particleNode
MPlug(pNode, particleNode::linearFriction).setValue(linearFriction);
}
}
return dgMod.doIt();
}
MStatus AlembicResolvePathCommand::doIt(const MArgList & args)
{
ESS_PROFILE_SCOPE("AlembicResolvePathCommand::doIt");
MStatus status = MS::kSuccess;
MArgParser argData(syntax(), args, &status);
if (argData.isFlagSet("help"))
{
MGlobal::displayInfo("[ExocortexAlembic]: ExocortexAlembic_resolvePath command:");
MGlobal::displayInfo(" -f : provide an unresolved fileName (string)");
return MS::kSuccess;
}
if(!argData.isFlagSet("fileNameArg"))
{
// TODO: display dialog
MGlobal::displayError("[ExocortexAlembic] No fileName specified.");
return status;
}
// get the filename arg
MString fileName = argData.flagArgumentString("fileNameArg",0);
setResult(resolvePath(fileName));
return status;
}
MStatus classificationCommand::doIt( const MArgList& args ){
MStatus stat = MS::kSuccess;
MString filePath,selectedList;
unsigned int selectedNum;
MArgDatabase argData( syntax(), args );
if( argData.isFlagSet( selectedNumFlag ) )
argData.getFlagArgument( selectedNumFlag, 0, selectedNum );
if( argData.isFlagSet( pathFlag ) )
argData.getFlagArgument( pathFlag, 0, filePath );
if( argData.isFlagSet( selectedFlag ) )
argData.getFlagArgument( selectedFlag, 0, selectedList );
MGlobal::displayInfo(selectedList);
std::string s = std::to_string((long double)selectedNum);
MString ms(s.c_str());
MGlobal::displayInfo(ms);
return stat;
}
MStatus AlembicProfileEndCommand::doIt(const MArgList& args) {
MStatus status = MS::kSuccess;
#ifdef ESS_PROFILING
MArgParser argData(syntax(), args, &status);
if(!argData.isFlagSet("fileNameArg"))
{
// TODO: display dialog
MGlobal::displayError("[ExocortexAlembic] No fileName specified.");
return status;
}
// get the filename arg
MString fileName = argData.flagArgumentString("fileNameArg",0);
std::string strFileName( fileName.asChar() );
if( nameToProfiler.find( strFileName ) != nameToProfiler.end() ) {
nameToProfiler[ strFileName ]->stop();
}
#endif
return status;
}
MStatus radiusCmd::doIt(const MArgList&args)
{
MStatus status=MStatus::kSuccess;
MArgDatabase argData(syntax(),args,&status);
if(argData.isFlagSet(rFlag))argData.getFlagArgument(rFlag,0,radius);
MItDag dagItr(MItDag::kDepthFirst, MFn::kInvalid,&status);
if(status!=MS::kSuccess){MGlobal::displayError(" Failure in DAG iterator");return status;}
for(;!dagItr.isDone();dagItr.next())
{
MDagPath dagPath;
status = dagItr.getPath(dagPath);
if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting path");return status;}
MFnDagNode dagNode(dagPath,&status);
if(dagNode.isIntermediateObject())continue;
if(!dagPath.hasFn(MFn::kDependencyNode))continue;
MObject mObj=dagNode.object(&status);
if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting object");return status;}
//getParticle
MFnDependencyNode fnNode(mObj, &status);
if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting dependency node");return status;}
if(fnNode.typeId() == OParticleNode::typeId) MPlug(mObj, OParticleNode::radius).setValue(radius);
}
return status;
}
MStatus GetMetaNodeConnectionCmd::parseArgs(const MArgList & args)
{
MStatus status;
if( args.length() == 0 ) {
return MS::kNotFound;
}
MArgDatabase argData(syntax(), args);
//get the node name argument
if (argData.isFlagSet(GetMetaNodeConnectionCmd::FileParam())) {
MString tmp;
status = argData.getFlagArgument(GetMetaNodeConnectionCmd::FileParam(), 0, tmp);
if (!status) {
status.perror("node flag parsing failed");
return status;
}
this->m_metaNodeName = tmp;
}
//get the connection name argument
if (argData.isFlagSet(GetMetaNodeConnectionCmd::FileParam2())) {
MString tmp;
status = argData.getFlagArgument(GetMetaNodeConnectionCmd::FileParam2(), 0, tmp);
if (!status) {
status.perror("connection flag parsing failed");
return status;
}
this->m_connectionName = tmp;
}
return MS::kSuccess;
}
MStatus TransferUV::doIt(const MArgList& args)
{
MStatus status;
// if (args.length() != 1)
// {
// MGlobal::displayError("Need 1 arg!");
// return MStatus::kFailure;
// }
MArgDatabase argData(syntax(), args);
// arg
// MString argument = args.asString(0, &status);
// if (status != MS::kSuccess) {
// return MStatus::kFailure;
// }
// CHECK_MSTATUS_AND_RETURN_IT(status);
if (argData.isFlagSet(sourceUvSetFlag)) {
status = argData.getFlagArgument(sourceUvSetFlag, 0, sourceUvSet);
CHECK_MSTATUS_AND_RETURN_IT(status);
}
if (argData.isFlagSet(targetUvSetFlag)) {
status = argData.getFlagArgument(targetUvSetFlag, 0, targetUvSet);
CHECK_MSTATUS_AND_RETURN_IT(status);
}
if (argData.isFlagSet(sourceMeshFlag)) {
status = argData.getFlagArgument(sourceMeshFlag, 0, sourceMesh);
} else {
MGlobal::displayError(
"Source mesh is not specified. -sm flag is required.");
return MS::kFailure;
}
if (argData.isFlagSet(targetMeshFlag)) {
status = argData.getFlagArgument(targetMeshFlag, 0, targetMesh);
} else {
MGlobal::displayError(
"Target mesh is not specified. -tm flag is required.");
return MS::kFailure;
}
MString info = "Copying uv from " + sourceUvSet + " to " + targetUvSet;
MGlobal::displayInfo(info);
MSelectionList mList;
mList.add(sourceMesh);
mList.add(targetMesh);
mList.getDagPath(0, sourceDagPath);
mList.getDagPath(1, targetDagPath);
return redoIt();
}
MStatus particlePathsCmd::parseArgs( const MArgList& args )
{
MArgDatabase argData(syntax(), args);
//
// Parse the time flags
//
if (argData.isFlagSet(startFlag))
{
argData.getFlagArgument(startFlag, 0, start);
}
if (argData.isFlagSet(finishFlag))
{
argData.getFlagArgument(finishFlag, 0, finish);
}
if (argData.isFlagSet(incrementFlag))
{
argData.getFlagArgument(incrementFlag, 0, increment);
}
if (finish <= start || increment <= 0.0)
{
MGlobal::displayError( "Invalid time arguments." );
return MS::kFailure;
}
//
// Get the particle system object
//
MSelectionList selectList;
argData.getObjects(selectList);
if( selectList.length() < 1 )
{
MGlobal::displayError( "Missing particle node name argument." );
return MS::kFailure;
}
else if( selectList.length() > 1 )
{
MGlobal::displayError( "Too many particle nodes given." );
return MS::kFailure;
}
selectList.getDependNode(0,particleNode);
if (particleNode.isNull() || !particleNode.hasFn(MFn::kParticle))
{
MGlobal::displayError( "Invalid node argument." );
return MS::kFailure;
}
return MS::kSuccess;
}
MStatus lockEvent::parseArgs( const MArgList &args )
{
MStatus status;
MArgDatabase argData( syntax(), args );
fAttach = kAttachDV;
fOverrideFlag = kOverrideDV;
fClearCB = kClearCBDV;
// begin-parse-args
if ( argData.isFlagSet( kClearCB ) ) {
fClearCB = !kClearCBDV;
}
if ( argData.isFlagSet( kOverride ) ) {
bool tmp;
status = argData.getFlagArgument( kOverride, 0, tmp );
if ( !status ) {
MGlobal::displayError( "override flag parsing failed" );
return status;
}
fOverrideFlag = !kOverrideDV;
fOverrideVal = tmp;
}
if ( argData.isFlagSet( kAttach ) ) {
unsigned int tmp;
status = argData.getFlagArgument( kAttach, 0, tmp );
if ( !status ) {
MGlobal::displayError( "attach flag parsing failed" );
return status;
}
fAttach = tmp;
}
if ( fAttach ) {
status = argData.getObjects( theList );
if ( theList.length() == 0 ) {
MString msg = "You must specify a node/plug to attach to!";
MGlobal::displayError(msg);
status = MS::kFailure;
}
}
// Ensure that the caller did not specify too many arguments!
//
if ( status && fAttach && fOverrideFlag ) {
MString msg = "You specified too many flags!" ;
MGlobal::displayError(msg);
status = MS::kFailure;
}
// end-parse-args
return status;
}
MStatus nodeInfo::parseArgs( const MArgList& args )
{
MStatus stat;
MArgDatabase argData(syntax(), args);
if (argData.isFlagSet(kQuietFlag))
quiet = true;
return stat;
}
MStatus SelectRingToolCmd2::doIt( const MArgList &args )
{
//MGlobal::displayInfo( "doIt" );
MStatus stat;
MGlobal::getActiveSelectionList( prevSel );
// Initialize to default values
selEdges = true;
selFaces = false;
selVertices = false;
selEdgeObject = MDagPath();
selEdgeComp = MObject::kNullObj;
listAdjust = MGlobal::kReplaceList;
selType = RING;
// Get the options from the command line
MArgDatabase argData( syntax(), args, &stat );
if( !stat )
return stat;
if( argData.isFlagSet( edgeFlag ) )
{
MString edgeSpec;
argData.getFlagArgument( edgeFlag, 0, edgeSpec );
MSelectionList sel;
sel.add( edgeSpec );
sel.getDagPath( 0, selEdgeObject, selEdgeComp );
//MFnSingleIndexedComponent si( selEdgeComp );
//MGlobal::displayInfo( MString("doing stuff on ") + selEdgeObject.fullPathName() + " " + si.element(0) );
}
if( argData.isFlagSet( selEdgesFlag ) )
argData.getFlagArgument( selEdgesFlag, 0, selEdges );
if( argData.isFlagSet( selFacesFlag ) )
argData.getFlagArgument( selFacesFlag, 0, selFaces );
if( argData.isFlagSet( selVerticesFlag ) )
argData.getFlagArgument( selVerticesFlag, 0, selVertices );
if( argData.isFlagSet( listAdjustFlag ) )
{
unsigned value;
argData.getFlagArgument( listAdjustFlag, 0, value );
listAdjust = MGlobal::ListAdjustment( value );
}
if( argData.isFlagSet( selTypeFlag ) )
argData.getFlagArgument( selTypeFlag, 0, selType );
return redoIt();
}
QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::call(Object *o, QScriptContext *ctxt)
{
MethodData *method = static_cast<MethodData *>(o);
if (method->data.flags & QDeclarativePropertyCache::Data::HasArguments) {
QMetaMethod m = method->object->metaObject()->method(method->data.coreIndex);
QList<QByteArray> argTypeNames = m.parameterTypes();
QVarLengthArray<int, 9> argTypes(argTypeNames.count());
// ### Cache
for (int ii = 0; ii < argTypeNames.count(); ++ii) {
argTypes[ii] = QMetaType::type(argTypeNames.at(ii));
if (argTypes[ii] == QVariant::Invalid)
return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii)))));
}
if (argTypes.count() > ctxt->argumentCount())
return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments")));
QVarLengthArray<MetaCallArgument, 9> args(argTypes.count() + 1);
args[0].initAsType(method->data.propType, engine);
for (int ii = 0; ii < argTypes.count(); ++ii)
args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii));
QVarLengthArray<void *, 9> argData(args.count());
for (int ii = 0; ii < args.count(); ++ii)
argData[ii] = args[ii].dataPtr();
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, argData.data());
return args[0].toValue(engine);
} else if (method->data.propType != 0) {
MetaCallArgument arg;
arg.initAsType(method->data.propType, engine);
void *args[] = { arg.dataPtr() };
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
return arg.toValue(engine);
} else {
void *args[] = { 0 };
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
return Value();
}
return Value();
}
MStatus particleCmd::doIt(const MArgList& args)
{
MStatus status=MStatus::kSuccess;
MArgDatabase argData(syntax(),args,&status);
if(argData.isFlagSet(pxFlag))argData.getFlagArgument(pxFlag,0,x);
if(argData.isFlagSet(pyFlag))argData.getFlagArgument(pyFlag,0,y);
if(argData.isFlagSet(pzFlag))argData.getFlagArgument(pzFlag,0,z);
if(status==MS::kFailure)return status;
return redoIt();
}
//*********************************************************
// Name: parseCommandFlags
// Desc: Parsed the command flags and stores the values
// in the appropriate variables
//*********************************************************
void BreakdownCommand::parseCommandFlags( const MArgList &args )
{
MArgDatabase argData( syntax(), args, &status );
if( !status ) {
pluginError( "BreakdownCommand", "parseCommandFlags",
"Failed to create MArgDatabase for the breakdown command" );
}
else {
if( argData.isFlagSet( weightFlag ))
argData.getFlagArgument( weightFlag, 0, breakdownWeight );
if( argData.isFlagSet( selectedAttrFlag ))
argData.getFlagArgument( selectedAttrFlag, 0, selectedAttrOnly );
if( argData.isFlagSet( ignoreRippleCheckFlag ))
argData.getFlagArgument( ignoreRippleCheckFlag, 0, ignoreRippleCheck );
if( argData.isFlagSet( tickDrawSpecialFlag ))
argData.getFlagArgument( tickDrawSpecialFlag, 0, tickDrawSpecial );
if( argData.isFlagSet( invalidAttrOpFlag )) {
MString strAttrOp;
argData.getFlagArgument( invalidAttrOpFlag, 0, strAttrOp );
if( strAttrOp == "skipAll" )
invalidAttrOp = kSkipAll;
else if( strAttrOp == "skipObject" )
invalidAttrOp = kSkipObject;
else if( strAttrOp == "skipAttr" )
invalidAttrOp = kSkipAttr;
else
MGlobal::displayWarning( "Invalid arguement for -invalidAttrOp. Using default value." );
}
if( argData.isFlagSet( modeFlag )) {
MString strMode;
argData.getFlagArgument( modeFlag, 0, strMode );
if( strMode == "overwrite" )
breakdownMode = Breakdown::kOverwrite;
else if( strMode == "ripple" )
breakdownMode = Breakdown::kRipple;
}
// Ripple mode ignores the selectedAttrOnly flag.
// All attributes will be affected.
if( breakdownMode == Breakdown::kRipple ) {
if( selectedAttrOnly == true ) {
selectedAttrOnly = false;
MGlobal::displayWarning( "Key Selected flag is ignored in Ripple Mode" );
}
}
}
}
MStatus Molecule3Cmd::doIt( const MArgList &args )
{
MStatus stat;
// Initialize options to default values
MFnTypedAttribute tAttr(
/*
radius.setValue( 0.1 );
segs = 6;
ballRodRatio = 2.0;
*/
selMeshes.clear();
// Get the options from the command line
MArgDatabase argData( syntax(), args, &stat );
if( !stat )
return stat;
if( argData.isFlagSet( radiusFlag ) )
argData.getFlagArgument( radiusFlag, 0, radius );
if( argData.isFlagSet( segsFlag ) )
argData.getFlagArgument( segsFlag, 0, segs );
if( argData.isFlagSet( ballRatioFlag ) )
argData.getFlagArgument( ballRatioFlag, 0, ballRodRatio );
// Get a list of currently selected objects
MSelectionList selection;
MGlobal::getActiveSelectionList( selection );
// Iterate over the meshes
MDagPath dagPath;
MItSelectionList iter( selection, MFn::kMesh );
for ( ; !iter.isDone(); iter.next() )
{
iter.getDagPath( dagPath );
selMeshes.append( dagPath );
}
if( selMeshes.length() == 0 )
{
MGlobal::displayWarning( "Select one or more meshes" );
return MS::kFailure;
}
return redoIt();
}
MStatus MeshControlCmd::doIt( const MArgList& args )
{
MStatus s;
MSelectionList selection;
MSyntax syn = syntax();
MArgDatabase argData(syn, args);
setResult(0);
if (argData.isFlagSet(m_nameFlag[1], &s))
{
MString nodeName; // 提取某个名字的节点
s = argData.getFlagArgument(m_nameFlag[1],0, nodeName);
s = MGlobal::getSelectionListByName(nodeName, selection);
}
else
s = MGlobal::getActiveSelectionList(selection); // 提取选中节点
if (!s)return MS::kSuccess;
bool isInitFlagSet = argData.isFlagSet(m_initFlag[1], &s);
MItSelectionList pSel(selection, MFn::kDependencyNode , &s);
MObject obj;
for (; !pSel.isDone(); pSel.next())
{
MObject depNode;
pSel.getDependNode(depNode);
MFnDependencyNode nodeFn(depNode, &s);
MString typeName = nodeFn.typeName(&s);
if (typeName != NODE_CAGE_DEFORMER_NAME)
continue;
CageDeformerNode* node = (CageDeformerNode*)nodeFn.userNode(&s);
if (!s)
continue;
if (isInitFlagSet)
{
s = node->computeWeight();
}
if (!s)
{
MGlobal::displayError("faild to compute weight");
}
else
MGlobal::displayInfo("succeed to compute weight");
}
return MS::kSuccess;
}
// parseArgs
//
MStatus viewCallbackTest::parseArgs(const MArgList& args)
{
MStatus status;
MArgDatabase argData(syntax(), args);
// Buffer operation argument variables
mBufferOperation = kInvertColorBuffer;
MString operationString;
MString arg;
for ( unsigned int i = 0; i < args.length(); i++ )
{
arg = args.asString( i, &status );
if (!status)
continue;
if ( arg == MString(bufferOperationShortName) || arg == MString(bufferOperationLongName) )
{
if (i == args.length()-1) {
arg += ": must specify a buffer operation.";
displayError(arg);
return MS::kFailure;
}
i++;
args.get(i, operationString );
bool validOperation = false;
for (unsigned int k=0; k<_NUMBER_BUFFER_OPERATIONS_; k++)
{
if (bufferOperationStrings[i] == operationString)
{
mBufferOperation = bufferOperations[k];
validOperation = true;
}
}
if (!validOperation)
status.perror("Invalid operation specified. Using invert by default.");
}
}
// Read off the panel name
status = argData.getCommandArgument(0, mPanelName);
if (!status)
{
status.perror("No panel name specified as command argument");
return status;
}
return MS::kSuccess;
}
MStatus
NeuronForMayaCmd::parseArgs( const MArgList& args )
{
MStatus status = MStatus::kSuccess;
MArgDatabase argData(syntax(), args);
if (argData.isFlagSet(kStartFlag))
status = argData.getFlagArgument(kStartFlag, 0, mStart);
if( argData.isFlagSet(kDeviceNameFlag))
status = argData.getFlagArgument(kDeviceNameFlag, 0, mDeviceName );
return status;
}
MStatus brushToolCommand::parseArgs(const MArgList& args)
{
MArgDatabase argData(syntax(), args);
MStatus status;
if (argData.isFlagSet(radiusFlag))
{
double tmp;
status=argData.getFlagArgument(radiusFlag, 0, tmp);
if (!status) {
status.perror("radius flag parsing failed");
return status;
}
radius=(float)tmp;
}
if (argData.isFlagSet(lockBaseFlag))
{
status=argData.getFlagArgument(lockBaseFlag, 0,lockbase);
if (!status) {
status.perror("lockbase flag parsing failed");
return status;
}
}
if (argData.isFlagSet(intensityFlag))
{
status=argData.getFlagArgument(intensityFlag, 0,inten);
if (!status) {
status.perror("intensity flag parsing failed");
return status;
}
}
if (argData.isFlagSet(brushModeFlag))
{
status=argData.getFlagArgument(brushModeFlag, 0,brushModeVal);
if (!status) {
status.perror("brush mode flag parsing failed");
return status;
}
}
return MS::kSuccess;
}
MStatus clusterWeightFunctionCmd::parseArgs(const MArgList &argList)
{
MArgDatabase argData(syntax(), argList);
if (argData.isFlagSet(kSineFlag)) {
fEffectType = kSine;
}
else if (argData.isFlagSet(kSineDistanceFlag)) {
fEffectType = kSineDistance;
}
else if (argData.isFlagSet(kSineDistance2Flag)) {
fEffectType = kSineDistance2;
}
else if (argData.isFlagSet(kDistanceSineDistanceFlag)) {
fEffectType = kDistanceSineDistance;
}
else if (argData.isFlagSet(kInverseDistanceSineDistanceFlag)) {
fEffectType = kInverseDistanceSineDistance;
}
else if (argData.isFlagSet(kDistanceFlag)) {
fEffectType = kDistance;
}
else if (argData.isFlagSet(kDistance2Flag)) {
fEffectType = kDistance2;
}
else if (argData.isFlagSet(kDistance3Flag)) {
fEffectType = kDistance3;
}
else if (argData.isFlagSet(kDistance4Flag)) {
fEffectType = kDistance4;
}
else if (argData.isFlagSet(kInverseDistanceFlag)) {
fEffectType = kInverseDistance;
}
else if (argData.isFlagSet(kInverseDistance2Flag)) {
fEffectType = kInverseDistance2;
}
else if (argData.isFlagSet(kInverseDistance3Flag)) {
fEffectType = kInverseDistance3;
}
else if (argData.isFlagSet(kInverseDistance4Flag)) {
fEffectType = kInverseDistance4;
}
return MS::kSuccess;
}
// parseArgs
//
MStatus eventTest::parseArgs(const MArgList& args)
{
MStatus status;
MArgDatabase argData(syntax(), args);
if (argData.isFlagSet(kMessageFlag))
{
bool flag;
status = argData.getFlagArgument(kMessageFlag, 0, flag);
if (!status)
{
status.perror("could not parse message flag");
return status;
}
if (flag)
{
addMessage = true;
}
else
{
delMessage = true;
}
}
status = argData.getObjects(events);
if (!status)
{
status.perror("could not parse event names");
}
// If there are no events specified, operate on all of them
//
if (events.length() == 0)
{
// eventNames is set in initializePlugin to all the
// currently available event names.
//
events = eventNames;
}
return status;
}
MStatus exportTerrain::parseArguments(const MArgList &args,
bool& phy)
{
MStatus status;
MArgDatabase argData(syntax(), args,&status);
if(!status){
fout << status << "Some error!";
return status;
}
phy=argData.isFlagSet(kPhysicsFlag);
return MStatus::kSuccess;
}
MStatus deletedMessage::doIt( const MArgList& args )
{
MStatus status = MS::kSuccess;
MArgDatabase argData(syntax(), args);
MSelectionList objects;
argData.getObjects(objects);
for (unsigned int i = 0; i < objects.length(); i++) {
MObject node;
objects.getDependNode(i, node);
callbackIds.append(
MNodeMessage::addNodeAboutToDeleteCallback (node, aboutToDeleteCB, NULL, &status)
);
if (!status) {
MGlobal::displayWarning("Could not attach about to delete callback for node.");
continue;
}
callbackIds.append(
MNodeMessage::addNodePreRemovalCallback (node, preRemovalCB, NULL, &status)
);
if (!status) {
MGlobal::displayWarning("Could not attach pre-removal callback for node.");
continue;
}
if (!nodeRemovedCBRegistered)
{
callbackIds.append(
MDGMessage::addNodeRemovedCallback(removeCB, "dependNode", NULL, &status)
);
if (!status) {
MGlobal::displayWarning("Could not attach node removal callback.");
continue;
}
nodeRemovedCBRegistered = true;
}
}
return status;
}
MStatus peltOverlap::parseArgs( const MArgList& args )
{
MStatus status = MS::kSuccess;
MArgDatabase argData(syntax(), args);
if (argData.isFlagSet(kExitFlag)) {
status = argData.getFlagArgument(kExitFlag, 0, fNthPairs);
if (status != MS::kSuccess) {
MGlobal::displayError("-ea/exitAfterNthPairs is missing an int argument");
return status;
}
}
status = argData.getObjects(fShadingGroups);
if (status != MS::kSuccess || fShadingGroups.length() < 1) {
MGlobal::displayError("Missing shading group(s) input");
status = MS::kFailure;
}
return status;
}
QDeclarativeObjectMethodScriptClass::Value
QDeclarativeObjectMethodScriptClass::callMethod(QObject *object, int index,
int returnType, int argCount, int *argTypes,
QScriptContext *ctxt)
{
if (argCount > 0) {
QVarLengthArray<MetaCallArgument, 9> args(argCount + 1);
args[0].initAsType(returnType, engine);
for (int ii = 0; ii < argCount; ++ii)
args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii));
QVarLengthArray<void *, 9> argData(args.count());
for (int ii = 0; ii < args.count(); ++ii)
argData[ii] = args[ii].dataPtr();
QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, argData.data());
return args[0].toValue(engine);
} else if (returnType != 0) {
MetaCallArgument arg;
arg.initAsType(returnType, engine);
void *args[] = { arg.dataPtr() };
QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
return arg.toValue(engine);
} else {
void *args[] = { 0 };
QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args);
return Value();
}
}
MStatus userMessage::doIt( const MArgList& args )
{
MStatus status = MS::kSuccess;
MArgDatabase argData(syntax(), args);
if (argData.isFlagSet(deregisterFlag))
{
MString event;
argData.getFlagArgument(deregisterFlag, 0, event);
status = MUserEventMessage::deregisterUserEvent(event);
}
else if (argData.isFlagSet(registerFlag))
{
// Register the new event and add two fixed callbacks to it.
MString event;
argData.getFlagArgument(registerFlag, 0, event);
if (!MUserEventMessage::isUserEvent(event)) {
status = MUserEventMessage::registerUserEvent(event);
if (status == MS::kSuccess)
{
MUserEventMessage::addUserEventCallback(event,userCallback1,(void*) &stringClientData,&status);
MUserEventMessage::addUserEventCallback(event,userCallback2,(void*) &stringClientData,&status);
}
}
}
else if (argData.isFlagSet(postFlag))
{
MString event;
argData.getFlagArgument(postFlag, 0, event);
status = MUserEventMessage::postUserEvent(event);
}
else if (argData.isFlagSet(testFlag))
{
runTests();
}
return status;
}
MStatus tm_polyExtract::doIt( const MArgList& args )
{
MStatus stat = MS::kSuccess;
clearResult();
MArgDatabase argData( syntax(), args);
// if(argData.isFlagSet( extractFaces_Flag))
{
MSelectionList selectionList;
argData.getObjects( selectionList);
MStringArray node_names;
bool result = extractFaces_Func( selectionList, node_names);
if(!result)
{
MGlobal::displayError("tm_polyExtract: extractFaces function call failed.");
return MStatus::kFailure;
}
setResult( node_names);
return stat;
}
}
MStatus nodeCreatedCB::doIt( const MArgList& args )
//
// Description:
// implements the MEL nodeCreatedCB command.
//
{
MStatus stat = MS::kSuccess;
MArgDatabase argData( syntax(), args );
// Parse command flags.
//
if ( argData.isFlagSet( kRegisterFlag ) ) {
// Register a new procedure.
//
MString proc;
argData.getFlagArgument( kRegisterFlag, 0, proc );
stat = registerMelProc( proc, argData.isFlagSet( kFullDagPathFlag ) );
} else if ( argData.isFlagSet( kUnregisterFlag ) ) {
// Unregister a procedure.
//
MString proc;
argData.getFlagArgument( kUnregisterFlag, 0, proc );
stat = unregisterMelProc( proc );
} else if ( argData.isFlagSet( kFilterFlag ) ) {
// Change the filter being applied.
//
MString filter;
argData.getFlagArgument( kFilterFlag, 0, filter );
stat = changeFilter( filter );
}
if ( stat.error() ) {
MGlobal::displayError( stat.errorString() );
}
return stat;
}
MStatus AlembicPolyMeshToSubdivCommand::doIt(const MArgList& args)
{
MStatus status;
MArgParser argData(syntax(), args, &status);
if (argData.isFlagSet("help"))
{
MGlobal::displayInfo("[ExocortexAlembic]: ExocortexAlembic_meshToSubdiv command:");
MGlobal::displayInfo(" -m : mesh to assign the initialShadingGroup on");
return MS::kSuccess;
}
const MString mesh = argData.isFlagSet("mesh") ? ("\"" + argData.flagArgumentString("mesh", 0) + "\"") : "";
MString result;
MGlobal::executePythonCommand(("ExoAlembic._functions.alembicPolyMeshToSubdiv(" + mesh) + ")", result);
if (result.length())
{
MPxCommand::setResult(result);
return MS::kFailure;
}
return MS::kSuccess;
}
