MStatus liqAttachPrefAttribute::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getObjects(objectNames); if (!status) { MGlobal::displayError("error parsing object list"); return MS::kFailure; } worldSpace = false; int flagIndex = args.flagIndex("ws", "worldSpace"); if (flagIndex != MArgList::kInvalidArgIndex) worldSpace = true; exportN = false; flagIndex = args.flagIndex("en", "exportN"); if (flagIndex != MArgList::kInvalidArgIndex) exportN = true; //printf(">> got %d objects to PREF !\n",objectNames.length() ); return redoIt(); }
MStatus CVstAimCmd::doIt( const MArgList &mArgList ) { // Specifying maya nodes on the command line doesn't work just saving // a copy of the arg list... probably it keeps pointers to strings // or something stupid like that, so have to parse the command line // into an MArgDatabase here and since there's no way to clean out // one, create a new one MStatus mStatus( MS::kSuccess ); MArgDatabase *mArgDatabase = new MArgDatabase( syntax(), mArgList, &mStatus ); if ( mArgDatabase ) { if ( mStatus ) { m_mArgDatabase = mArgDatabase; mStatus = redoIt(); } else { delete mArgDatabase; } } return mStatus; }
//----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- MStatus CVstSelectCoincidentFacesCmd::doIt( const MArgList &mArgList ) { if ( m_undo.SetArgList( syntax(), mArgList ) ) return redoIt(); return MS::kFailure; }
MStatus GetMetaNodeConnectionCmd::doIt ( const MArgList &args ) { MStatus status; MStatus paramStatus = parseArgs(args); MObject metaNodeObj; status = lrutils::getObjFromName(this->m_metaNodeName, metaNodeObj); MyCheckStatus(status, "lrutils::getObjFromName() failed"); MObject connectedObj; status = lrutils::getMetaNodeConnection(metaNodeObj, connectedObj, this->m_connectionName); MyCheckStatus(status, "lrutils::getMetaNodeConnection() failed"); if( connectedObj.hasFn(MFn::kDagNode) ) { MFnDagNode connectedFn(connectedObj); MString dagPath = connectedFn.fullPathName(); setResult(dagPath); } else { MFnDependencyNode connectedFn(connectedObj); MString name = connectedFn.name(); setResult(name); } return redoIt(); }
MStatus CustomSphere::doIt( const MArgList& _args ) { // set some default values m_count=100; m_xExtent=20; m_yExtent=20; m_zExtent=20; m_minRadius=0.2; m_maxRadius=2.5; // lets process the command line arguments MStatus status; MString arg; // Create a parser for our arguments using the syntax for this command, // and the args passed to the function by the user MArgDatabase parser(syntax(),_args,&status); if(status != MS::kSuccess) { CHECK_STATUS_AND_RETURN_IF_FAIL(status,"error parsing arguments"); } // if the help flag is set, display some useful info. if(parser.isFlagSet("-h")) { MGlobal::displayInfo(g_HelpText); return MS::kSuccess; } // // get the command line arguments that were specified // if(parser.isFlagSet("-n")) { parser.getFlagArgument( "-n", 0, m_count ); } if(parser.isFlagSet("-mr")) { parser.getFlagArgument( "-mr", 0, m_minRadius ); } if(parser.isFlagSet("-mm")) { parser.getFlagArgument( "-mm", 0, m_maxRadius ); } if(parser.isFlagSet("-x")) { parser.getFlagArgument( "-x", 0, m_xExtent ); } if(parser.isFlagSet("-y")) { parser.getFlagArgument( "-y", 0, m_yExtent ); } if(parser.isFlagSet("-z")) { parser.getFlagArgument( "-z", 0, m_zExtent ); } // now call the redoIt method which actually does the work return redoIt(); }
//----------------------------------------------------------------------------- // Purpose: When this command is executed by Maya for the first time, // a new instance of the command class is created and this function // is called with the specified command line arguments // Input : The command line arguments specified by the user // Output : MStatus indicating success or failure of the command // In order for the command to be kept in the undo stack // the return value must be MStatus::kSuccess // Also the virtual isUndoable() has to return true for the // command to be kept in the undo stack for later undoing //----------------------------------------------------------------------------- MStatus CVstSmdIOCmd::doIt( const MArgList &mArgList ) { if ( m_undo.SetArgList( syntax(), mArgList ) ) return redoIt(); return MS::kFailure; }
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 convertVerticesToContainedEdgesCommand::doIt(const MArgList& args) { MGlobal::getActiveSelectionList(previousSelectionList); return redoIt(); }
MStatus dHingeConstraintCmd::doIt(const MArgList &args) { MStatus stat; m_argDatabase = new MArgDatabase(syntax(), args, &stat); if (stat == MS::kFailure) { return stat; } return redoIt(); }
MStatus createBoingRBCmd::doIt(const MArgList &args) { MStatus stat; m_argDatabase = new MArgDatabase(syntax(), args, &stat); if (stat == MS::kFailure) { return stat; } return redoIt(); }
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(); }
virtual MStatus doIt( const MArgList& ) { MStatus stat = M3dView::active3dView().getCamera( camera ); if ( MS::kSuccess == stat ) { redoIt(); } else { cerr << "Error getting camera" << endl; } return stat; }
//********************************************************* // Name: doIt // Desc: All of the one-time setup and initialization // code for the breakdown command. doIt is called // by Maya when any command is executed in MEL. // Any code that changes the state of Maya is // handled by the redoIt method. //********************************************************* MStatus BreakdownCommand::doIt( const MArgList &args ) { parseCommandFlags( args ); getSelectedObjects(); if( selectionList.length() == 0 ) { MGlobal::displayError( "No Objects Selected" ); status = MS::kFailure; } else if( selectedAttrOnly && (populateSelectedAttributeList() == 0) ) { MGlobal::displayError( "No Attributes Selected" ); status = MS::kFailure; } else { MStringArray results; selectionList.getSelectionStrings( results ); if( !createBreakdownList()) { // Create breakdown will display its own error } // When in ripple mode, the default behaviour is to verify that // all attributes have a key set at the current time or all keys // have no keys set at the current time. The ripple breakdown // will fail if this is not the case unless the check is disabled. else if( breakdownMode == Breakdown::kRipple && !ignoreRippleCheck && !(status = breakdownList.areOriginalKeysUniform()) ) { MGlobal::displayError( "Breakdown Failed. (Ripple Mode)All attributes must have a key set or no keys set at the current time." ); } else { if( !redoIt() ) { pluginError( "BreakdownCommand", "doIt", "Failed to redoIt" ); } else { MString output( "Result: " ); output += breakdownList.size(); if( attributesSkipped ) output += " (See Script Editor for skipped attributes)"; else if( objectsSkipped ) output += " (See Script Editor for skipped objects)"; MGlobal::displayInfo( output ); } } } return status; }
MStatus boingRbCmd::doIt(const MArgList &args) { MStatus stat; argParser = new MArgParser(syntax(), args, &stat); if (stat == MS::kFailure) { cerr<<"failed to read argData"<<endl; return stat; } return redoIt(); }
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(); }
MStatus blindDoubleDataCmd::doIt( const MArgList& ) { MStatus stat; // Create a selection list iterator // MSelectionList list; MGlobal::getActiveSelectionList( list ); iter = new MItSelectionList( list, MFn::kInvalid, &stat ); if ( MS::kSuccess == stat ) stat = redoIt(); return stat; }
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 skinClusterWeights::doIt( const MArgList& args ) // // Description // { MStatus status = parseArgs(args); if (status != MS::kSuccess) return status; if (editUsed) { redoIt(); } else if (queryUsed) { doItQuery(); } return MS::kSuccess; }
MStatus helix2::doIt( const MArgList& args ) { MStatus status; // Parse the arguments. for ( unsigned i = 0; i < args.length(); i++ ) { if ( MString( "-p" ) == args.asString( i, &status ) && MS::kSuccess == status) { double tmp = args.asDouble( ++i, &status ); if ( MS::kSuccess == status ) pitch = tmp; } else if ( MString( "-r" ) == args.asString( i, &status ) && MS::kSuccess == status) { double tmp = args.asDouble( ++i, &status ); if ( MS::kSuccess == status ) radius = tmp; } else { MString msg = "Invalid flag: "; msg += args.asString( i ); displayError( msg ); return MS::kFailure; } } // Get the first selected curve from the selection list. MSelectionList slist; MGlobal::getActiveSelectionList( slist ); MItSelectionList list( slist, MFn::kNurbsCurve, &status ); if (MS::kSuccess != status) { cerr << "doIt: could not create selection list iterator\n"; return status; } if (list.isDone()) { cerr << "doIt: no curve has been selected\n"; return MS::kFailure; } list.getDagPath( fDagPath, fComponent ); return redoIt(); }
MStatus motionTrace::doIt( const MArgList& args ) // // Description // This method is called from MEL when this command is called. // It should set up any class data necessary for redo/undo, // parse any given arguments, and then call redoIt. // { start = 1.0; end = 60.0; by = 1.0; MStatus stat; double tmp; unsigned i; // Parse the arguments. for ( i = 0; i < args.length(); i++ ) { if ( MString( "-s" ) == args.asString( i, &stat ) && MS::kSuccess == stat) { tmp = args.asDouble( ++i, &stat ); if ( MS::kSuccess == stat ) start = tmp; } else if ( MString( "-e" ) == args.asString( i, &stat ) && MS::kSuccess == stat) { tmp = args.asDouble( ++i, &stat ); if ( MS::kSuccess == stat ) end = tmp; } else if ( MString( "-b" ) == args.asString( i, &stat ) && MS::kSuccess == stat) { tmp = args.asDouble( ++i, &stat ); if ( MS::kSuccess == stat ) by = tmp; } } stat = redoIt(); return stat; }
MStatus liqWriteArchive::doIt(const MArgList& args) { MStatus status; MArgParser argParser(syntax(), args); MString tempStr; status = argParser.getCommandArgument(0, tempStr); if (!status) { MGlobal::displayError("error parsing object name argument"); return MS::kFailure; } objectNames.append(tempStr); status = argParser.getCommandArgument(1, outputFilename); if (!status) { MGlobal::displayError("error parsing rib filename argument"); return MS::kFailure; } outputRootTransform = false; int flagIndex = args.flagIndex("rt", "rootTransform"); if (flagIndex != MArgList::kInvalidArgIndex) { outputRootTransform = true; } outputChildTransforms = true; flagIndex = args.flagIndex("ct", "childTransforms"); if (flagIndex != MArgList::kInvalidArgIndex) { outputChildTransforms = true; } debug = false; flagIndex = args.flagIndex("d", "debug"); if (flagIndex != MArgList::kInvalidArgIndex) { debug = true; } binaryRib = false; flagIndex = args.flagIndex("b", "binary"); if (flagIndex != MArgList::kInvalidArgIndex) { binaryRib = true; } return redoIt(); }
MStatus boingRbCmd::doIt(const MArgList &args) { MStatus stat; argParser = new MArgDatabase(syntax(), args, &stat); if (stat == MS::kFailure) { cerr<<"failed to read args"<<endl; return stat; } argsList = new MArgList( args ); //std::cout<<"argsList : "<<*argsList<<std::endl; return redoIt(); }
//----------------------------------------------------------------------------- // // Purpose: When this command is executed by Maya for the first time, // a new instance of the command class is created and this function // is called with the specified command line arguments // Input : The command line arguments specified by the user // Output : MStatus indicating success or failure of the command // In order for the command to be kept in the undo stack // the return value must be MStatus::kSuccess // Also the virtual isUndoable() has to return true for the // command to be kept in the undo stack for later undoing // //----------------------------------------------------------------------------- MStatus CVstAttachmentCmd::doIt( const MArgList &mArgList ) { MStatus mStatus; MArgDatabase *mArgDatabase( new MArgDatabase( syntax(), mArgList, &mStatus ) ); if ( mArgDatabase ) { if ( mStatus ) { m_mArgDatabase = mArgDatabase; mStatus = redoIt(); } else { delete mArgDatabase; } } return mStatus; }
MStatus ribGenCmd::doIt( const MArgList& args) { /*=========================================* * the parameters of command * =========================================*/ MString ribPath, shaderPath; unsigned index; index = args.flagIndex("p", "ribPath"); if(MArgList::kInvalidArgIndex != index) args.get(index+1, ribPath); index = args.flagIndex("sp", "shaderPath"); if(MArgList::kInvalidArgIndex != index) args.get(index+1, shaderPath); /*=========================================* * shaderPath & ribPath *=========================================*/ RtToken shader= new char[50] , path=new char[50]; strcpy(shader, shaderPath.asChar()); strcpy(path, ribPath.asChar()); char *curve[] = {"curves"}; RtMatrix identityMatrix = { { 1, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 0, 1 }}; RtInt ustep, vstep; ustep = vstep =1; /*=====================================* * Begenning of writting out the .rib file. *=====================================*/ RiBegin(path); RiAttributeBegin(); RiTransformBegin(); //RiSurface(shader); RiTransformEnd(); //RiAttribute("identifier", "name", curve); RiConcatTransform(identityMatrix); RiShadingInterpolation(RI_SMOOTH); RiBasis(RiBezierBasis, ustep, RiBezierBasis, vstep); int nodeId = 0, knotNum = 0; float baseWidth = 0.0f, tipWidth = 0.0f; MObject surface, node; /*=========================================* * get the informations of selected Objects in scene. *=========================================*/ MSelectionList selection; MGlobal::getActiveSelectionList(selection); MItSelectionList iter(selection, MFn::kNurbsSurface ); for(; !iter.isDone(); iter.next()) { RtInt numCurves = 0; RtInt numVertexs = 0; /*======================================* * get the drawHairNode from selected NurbsSurface. *======================================*/ iter.getDependNode(surface); MFnDependencyNode surfaceFn(surface); MStatus state; MPlug plug = surfaceFn.findPlug("worldSpace",false, &state); plug = plug.elementByLogicalIndex(0); MPlugArray desPlugs; plug.connectedTo(desPlugs,false,true); plug = desPlugs[0]; node = plug.node(); //drawHairNode has found here!! /*=====================================* * get the attributes of drawHairNode. *=====================================*/ MFnDependencyNode hairNodeFn(node); plug = hairNodeFn.findPlug("nodeId"); plug.getValue(nodeId); MGlobal::displayInfo(MString(" nodeId: ")+nodeId); plug = hairNodeFn.findPlug("number"); plug.getValue(numCurves); plug= hairNodeFn.findPlug("smooth"); plug.getValue(knotNum); plug = hairNodeFn.findPlug("baseWidth"); plug.getValue(baseWidth); plug = hairNodeFn.findPlug("tipWidth"); plug.getValue(tipWidth); /*=====================================* * caculate the linear interpolate of the width of the curve. *=====================================*/ numVertexs = numCurves * knotNum; int widthNum = numCurves * (knotNum -2 ); float *curveWidth = new float[widthNum]; float widthStep = 0.0f; for(int c=0; c<widthNum; ++c){ widthStep = ((c%(knotNum-2)) / (float)(knotNum-3)) *(tipWidth - baseWidth); if(widthStep < epslion) widthStep = 0.0f; curveWidth[c] = baseWidth + widthStep; } RtInt *nvertices = new RtInt[numCurves]; //the numbers of vertices on each curve. RtPoint *vertexs = new RtPoint[numVertexs]; //the total vertexs. /*=====================================* * nvertices[] assignment. *=====================================*/ for(int j=0; j<numCurves ; ++j){ nvertices[j] = knotNum; } /*=====================================* * get the hair's datas from the static member * named "nodeManager" of the drawHairNode class. *=====================================*/ nodeMap::iterator iter = drawHairNode::nodeManager.find(nodeId); vector<MPointArray> helixVec = iter->second; /*=====================================* * vertexs[] assignment. *=====================================*/ float x=0, y=0, z=0; int countVT=0; for(vector<MPointArray>::iterator it=helixVec.begin(); it != helixVec.end(); ++it){ MPointArray helixCurve = (MPointArray)(*it); for(int k=0; k < helixCurve.length() ; ++k){ x = helixCurve[k].x; if(fabs(x) < epslion) vertexs[countVT][0] = 0; else vertexs[countVT][0] = helixCurve[k].x; y = helixCurve[k].y; if(fabs(y) < epslion) vertexs[countVT][1] = 0; else vertexs[countVT][1] = helixCurve[k].y; z = helixCurve[k].z; if(fabs(z) < epslion) vertexs[countVT++][2] = 0; else vertexs[countVT++][2] = helixCurve[k].z; } } RiCurves( RI_CUBIC, numCurves, nvertices, RI_NONPERIODIC, RI_P, vertexs, RI_WIDTH, curveWidth, RI_NULL); } RiAttributeEnd(); RiEnd(); return redoIt(); }
MStatus closestPointOnCurveCommand::doIt(const MArgList& args) { // CREATE THE PARSER: MArgDatabase argData(syntax(), args); // STORE FLAG INDICATORS, STORING WHETHER EACH FLAG HAS BEEN SET OR NOT: queryFlagSet = argData.isQuery(); inPositionFlagSet = argData.isFlagSet("inPosition"); positionFlagSet = argData.isFlagSet("-position"); normalFlagSet = argData.isFlagSet("-normal"); tangentFlagSet = argData.isFlagSet("-tangent"); paramUFlagSet = argData.isFlagSet("-paramU"); distanceFlagSet = argData.isFlagSet("-distance"); // STORE THE NAME OF THE "closestPointOnCurve" NODE IF SPECIFIED, OTHERWISE ASSIGN DEFAULT: if (argData.isFlagSet("-name")) argData.getFlagArgument("-name", 0, closestPointOnCurveNodeName); else closestPointOnCurveNodeName = ""; // STORE THE "inPosition" IF SPECIFIED, OTHERWISE ASSIGN DEFAULT: if (inPositionFlagSet) { argData.getFlagArgument("-inPosition", 0, inPosition.x); argData.getFlagArgument("-inPosition", 1, inPosition.y); argData.getFlagArgument("-inPosition", 2, inPosition.z); } else { inPosition.x = 0.0; inPosition.y = 0.0; inPosition.z = 0.0; } // STORE THE SPECIFIED OBJECT, INPUTTED FROM EITHER THE COMMAND ARGUMENT OR CURRENT SELECTION: argData.getObjects(sList); return redoIt(); }
MStatus cvPos::doIt( const MArgList& args ) { MString componentName; MSpace::Space transformSpace = MSpace::kWorld; for (unsigned int i = 0; i < args.length (); i++) { MString argStr; args.get (i, argStr); if (MString ("-l") == argStr || MString ("-local") == argStr) transformSpace = MSpace::kObject; else if (MString ("-w") == args.asString (i) || MString ("-world") == argStr) transformSpace = MSpace::kWorld; else componentName = argStr; } MObject component; MDagPath dagPath; if (!componentName.length ()) { MSelectionList activeList; MGlobal::getActiveSelectionList (activeList); MItSelectionList iter (activeList, MFn::kComponent); if (iter.isDone ()) { displayError ("No components selected"); return MS::kFailure; } else { iter.getDagPath (dagPath, component); iter.next (); if (!iter.isDone ()) { displayError ("More than one component is selected"); return MS::kFailure; } } } else { MSelectionList list; if (! list.add( componentName ) ) { componentName += ": no such component"; displayError(componentName); return MS::kFailure; // no such component } MItSelectionList iter( list ); iter.getDagPath( dagPath, component ); } if (component.isNull()) { displayError("not a component"); return MS::kFailure; } switch (component.apiType()) { case MFn::kCurveCVComponent: { MItCurveCV curveCVIter( dagPath, component ); point = curveCVIter.position(transformSpace ); curveCVIter.next(); if (!curveCVIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } case MFn::kSurfaceCVComponent: { MItSurfaceCV surfCVIter( dagPath, component, true ); point = surfCVIter.position(transformSpace ); surfCVIter.next(); if (!surfCVIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } case MFn::kMeshVertComponent: { MItMeshVertex vertexIter( dagPath, component ); point = vertexIter.position(transformSpace ); vertexIter.next(); if (!vertexIter.isDone()) { displayError ("More than one component is selected"); return MS::kFailure; } break; } default: cerr << "Selected unsupported type: (" << component.apiType() << "): " << component.apiTypeStr() << endl; } return redoIt(); }
MStatus TransferVertex::doIt( const MArgList& args) { MStatus status; // if (args.length() != 1) { // MGlobal::displayError("Need one arg"); // return MStatus::kFailure; // } // arg // MString argument = args.asString(0, &status); // if (status != MS::kSuccess) { // return MStatus::kFailure; // } // CHECK_MSTATUS_AND_RETURN_IT(status); MArgDatabase argData(syntax(), args); if (argData.isFlagSet(sourceUvSetFlag)) { status = argData.getFlagArgument(sourceUvSetFlag, 0, sourceUvSet); } else { sourceUvSet = "map1"; } if (argData.isFlagSet(targetUvSetFlag)) { status = argData.getFlagArgument(targetUvSetFlag, 0, targetUvSet); } else { targetUvSet = "map1"; } if (argData.isFlagSet(toleranceFlag)) { status = argData.getFlagArgument(toleranceFlag, 0, tolerance); } else { tolerance = 0.0001; } if (argData.isFlagSet(sourceMeshFlag)) { status = argData.getFlagArgument(sourceMeshFlag, 0, sourceMesh); CHECK_MSTATUS_AND_RETURN_IT(status); } else { MGlobal::displayError("source mesh not specified"); return MS::kFailure; } if (argData.isFlagSet(targetMeshFlag)) { status = argData.getFlagArgument(targetMeshFlag, 0, targetMesh); CHECK_MSTATUS_AND_RETURN_IT(status); } else { MGlobal::displayError("target mesh not specified"); return MS::kFailure; } MSelectionList mList; // MGlobal::getActiveSelectionList(mList); mList.add(sourceMesh); mList.add(targetMesh); MDagPath sourceDagPath; MDagPath targetDagPath; mList.getDagPath(0, sourceDagPath); mList.getDagPath(1, targetDagPath); MGlobal::displayInfo(sourceDagPath.fullPathName()); MGlobal::displayInfo(targetDagPath.fullPathName()); sourceFnMesh.setObject(sourceDagPath); targetFnMesh.setObject(targetDagPath); MString uvSetName = "map1"; MString* uvSetPtr = &uvSetName; MIntArray polygonIds; MPointArray points; MIntArray faceIndices; targetFnMesh.getPoints(originalPositions); targetFnMesh.getPoints(newPositions); // UVset MString souceUVSetOrig = sourceFnMesh.currentUVSetName(); sourceFnMesh.setCurrentUVSetName(sourceUvSet); MString targetUVSetOrig = targetFnMesh.currentUVSetName(); targetFnMesh.setCurrentUVSetName(targetUvSet); for (MItMeshVertex itVerts(targetDagPath); !itVerts.isDone(); itVerts.next()) { itVerts.getConnectedFaces(faceIndices); int numFaces = faceIndices.length(); for (int i=0; i<numFaces; i++) { int index = faceIndices[i]; float uv[2]; itVerts.getUV(index, uv, &targetUvSet); status = sourceFnMesh.getPointsAtUV( polygonIds, points, uv, MSpace::kObject, &sourceUvSet, tolerance); if (status == MS::kSuccess) { int length = points.length(); if (length != 0) { newPositions[itVerts.index()] = points[0]; } } } } targetFnMesh.setPoints(newPositions); sourceFnMesh.setCurrentUVSetName(souceUVSetOrig); targetFnMesh.setCurrentUVSetName(targetUVSetOrig); return redoIt(); }
MStatus iffPixel::doIt( const MArgList& args ) { MString componentName; if (args.length () < 3 || args.length () > 4) { displayError ("Syntax: iffPixel file x y [-depth]"); return MS::kFailure; } int x,y; MString fileName; args.get (0, fileName); args.get (1, x); args.get (2, y); if (args.length () == 4) { MString lastArg; args.get (3, lastArg); if (lastArg != MString ("-depth")) { displayError ("Syntax: iffPixel file x y [-depth]"); return MS::kFailure; } useDepth = true; } else useDepth = false; IFFimageReader reader; MStatus stat; stat = reader.open (fileName); IFFCHECKERR (stat, open); int w,h; stat = reader.getSize (w,h); IFFCHECKERR (stat, getSize); if (x < 0 || x > w || y < 0 || y > h) { MString message ("Co-ordinates out of range. Size of image is "); message += itoa (w); message += "+"; message += itoa (h); displayError (message); return MS::kFailure; } stat = reader.readImage (); IFFCHECKERR (stat, readImage); if (useDepth) { if (!reader.hasDepthMap ()) { displayError ("Image has no depth map"); return MS::kFailure; } stat = reader.getDepth (x,y,&d); } else { if (!reader.isRGB () && !reader.isGrayscale ()) { displayError ("Image has no RGB data"); return MS::kFailure; } stat = reader.getPixel (x,y,&r,&g,&b,&a); } IFFCHECKERR (stat, getPixel); stat = reader.close (); IFFCHECKERR (stat, close); return redoIt(); }
MStatus tm_randPoint::doIt( const MArgList& args ) { MStatus stat = MS::kSuccess; double amp = 1.0; double amp_x = 1.0; double amp_y = 1.0; double amp_z = 1.0; unsigned int seed = 0; bool useAxisAmp = false; bool exactObject = false; unsigned int num_meshes; MString objMString; helpMode = false; MArgDatabase argData( syntax(), args); if(argData.isFlagSet( help_Flag)) { helpMode = true; appendToResult( "\n// tm_polygon randPoint usage:\n"); appendToResult( "// Command operates with specified object with \"-obj\" flag,\n"); appendToResult( "// if this flag is not set, command use selected poly objects or poly vertices.\n"); appendToResult( "// Synopsis: tm_polygon [flags].\n"); appendToResult( "// Type \"help tm_randPoint\" to query flags.\n"); return MS::kSuccess; } if(argData.isFlagSet( amp_Flag)) argData.getFlagArgument( amp_Flag, 0, amp); if(argData.isFlagSet( ampX_Flag)) { argData.getFlagArgument( ampX_Flag, 0, amp_x); useAxisAmp = true; } if(argData.isFlagSet( ampY_Flag)) { argData.getFlagArgument( ampY_Flag, 0, amp_y); useAxisAmp = true; } if(argData.isFlagSet( ampZ_Flag)) { argData.getFlagArgument( ampZ_Flag, 0, amp_z); useAxisAmp = true; } if(argData.isFlagSet( seed_Flag)) argData.getFlagArgument( seed_Flag, 0, seed); if(argData.isFlagSet( obj_Flag)) { exactObject = true; argData.getFlagArgument( obj_Flag, 0, objMString); } double randMax = (double)RAND_MAX; double halfRandMax = 0.5 * randMax; unsigned i; if( exactObject) { selVtxMode = false; MSelectionList m_selList; MDagPath m_dagPath; stat = m_selList.add( objMString); if (!stat){stat.perror("###1 invalid obect path string");return stat;} stat = m_selList.getDagPath( 0, m_dagPath); if (!stat){stat.perror("###2 invalid obect path string");return stat;} stat = res_MDagPathArray.append( m_dagPath); if (!stat){stat.perror("###3 invalid obect path string");return stat;} } else { MSelectionList curSel; MGlobal::getActiveSelectionList( curSel); unsigned int numSelected = curSel.length(); MItSelectionList iter( curSel, MFn::kMeshVertComponent); if (iter.isDone()) { selVtxMode = false; MItDag::TraversalType traversalType = MItDag::kBreadthFirst; MFn::Type filter = MFn::kMesh; MItDag mit_dag( traversalType, filter, &stat); for( i = 0; i < numSelected; i++ ) { MDagPath sel_dagPath; curSel.getDagPath( i, sel_dagPath); stat = mit_dag.reset( sel_dagPath, traversalType, filter); if ( !stat) { stat.perror("MItDag constructor");return stat;} for ( ; !mit_dag.isDone(); mit_dag.next() ) { MDagPath m_dagPath; stat = mit_dag.getPath(m_dagPath); if ( !stat ) { stat.perror("MItDag::getPath error"); continue;} stat = res_MDagPathArray.append( m_dagPath); if ( !stat ) { stat.perror("MDagPathArray.append error"); continue;} } } } else { newPointsArrays = new MPointArray[1]; oldPointsArrays = new MPointArray[1]; selVtxMode = true; MObject component; MDagPath selVtx_dagPath; for ( ; !iter.isDone(); iter.next() ) { iter.getDagPath(selVtx_dagPath, component); MItMeshVertex vertexIter( selVtx_dagPath, component ); for ( ; !vertexIter.isDone(); vertexIter.next() ) { MPoint oldPoint = vertexIter.position(MSpace::kObject ); MPoint newPoint; newPoint.x = oldPoint.x + ((halfRandMax - (double)rand()) / randMax) * amp * amp_x; newPoint.y = oldPoint.y + ((halfRandMax - (double)rand()) / randMax) * amp * amp_y; newPoint.z = oldPoint.z + ((halfRandMax - (double)rand()) / randMax) * amp * amp_z; oldPointsArrays[0].append( oldPoint); newPointsArrays[0].append( newPoint); } } } } if(!selVtxMode) { num_meshes = res_MDagPathArray.length(); newPointsArrays = new MPointArray[num_meshes]; oldPointsArrays = new MPointArray[num_meshes]; for( i = 0; i < num_meshes; i++ ) { MDagPath dagPath = res_MDagPathArray[i]; MObject node; node = dagPath.node(); MFnDependencyNode fnNode( node ); MStatus polyStatus; MFnMesh fnMesh( node, &polyStatus ); if( polyStatus == MS::kSuccess ) { MStatus status; status = fnMesh.getPoints( oldPointsArrays[i]); if (!status){status.perror("### error getting mesh points");return stat;} unsigned int numVertices = oldPointsArrays[i].length(); newPointsArrays[i].setLength(numVertices); oldPointsArrays[i].setLength(numVertices); if(seed != 0) srand(seed); if(useAxisAmp) { for( unsigned int v = 0; v < numVertices; v++) { newPointsArrays[i][v].x = oldPointsArrays[i][v].x + ((halfRandMax - (double)rand()) / randMax) * amp * amp_x; newPointsArrays[i][v].y = oldPointsArrays[i][v].y + ((halfRandMax - (double)rand()) / randMax) * amp * amp_y; newPointsArrays[i][v].z = oldPointsArrays[i][v].z + ((halfRandMax - (double)rand()) / randMax) * amp * amp_z; } } else { for( unsigned int v = 0; v < numVertices; v++) { newPointsArrays[i][v].x = oldPointsArrays[i][v].x + ((halfRandMax - (double)rand()) / randMax) * amp; newPointsArrays[i][v].y = oldPointsArrays[i][v].y + ((halfRandMax - (double)rand()) / randMax) * amp; newPointsArrays[i][v].z = oldPointsArrays[i][v].z + ((halfRandMax - (double)rand()) / randMax) * amp; } } } else stat = MS::kFailure; } } return redoIt(); }
MStatus smSolverCmd::doIt(const MArgList& arg) { return redoIt(); }