MStatus splitUV::pruneUVs( MIntArray& validUVIndices ) // // Description: // // This method will remove any invalid UVIds from the component list and UVId array. // The benefit of this is to reduce the amount of extra processing that the node would // have to perform. It will result in less iterations through the mesh as there are // less UVs to search for. // { MStatus status; unsigned i; MIntArray validUVIds; for( i = 0; i < validUVIndices.length(); i++ ) { int uvIndex = validUVIndices[i]; validUVIds.append( fSelUVs[uvIndex] ); } // Replace the local int array of UVIds // fSelUVs.clear(); fSelUVs = validUVIds; // Build the list of valid components // MFnSingleIndexedComponent compFn; compFn.create( MFn::kMeshMapComponent, &status ); MCheckStatus( status, "compFn.create( MFn::kMeshMapComponent )" ); status = compFn.addElements( validUVIds ); MCheckStatus( status, "compFn.addElements( validUVIds )" ); MObject component = compFn.object(); // Replace the component list // MFnComponentListData compListFn; compListFn.create(); status = compListFn.add( component ); MCheckStatus( status, "compListFn.add( component )" ); fComponentList = compListFn.object(); return status; }
MStatus tm_polySlot::doIt( const MArgList& ) // // Description: // implements the MEL tm_polySlot command. // // Arguments: // args - 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. // { #ifdef _DEBUG cout << endl << "####################################################" << endl; cout << "tm_polySlot::doIt - DEBUG version info:" << endl; #endif MStatus status; // Parse the selection list for objects with selected UV components. // To simplify things, we only take the first object that we find with // selected UVs and operate on that object alone. // // All other objects are ignored and return warning messages indicating // this limitation. // MGlobal::getActiveSelectionList( oldSelList ); MItSelectionList selListIter( oldSelList ); selListIter.setFilter( MFn::kMesh ); // The tm_polySlot 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 edgesIds, // 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 UV components // if( component.apiType() == MFn::kMeshEdgeComponent ) { 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 edgesIds of the selected Edges 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 ); compFn.getElements( fSelEdges ); // 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 UVs, 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 Edges - Only operating on first found object."); } if( !found ) { displayError( "tm_polySlot command failed: Unable to find selected edges" ); return MStatus::kFailure; } // Initialize the polyModifierCmd node type - mesh node already set // setModifierNodeType( tm_polySlotNode::id ); //################################################################## alwaysWithConstructionHistory = true; status = doModifyPoly(); if( !status){displayError( "tm_polySlot command failed!" );return status;} //################################################################## get polymodifier node name and select it getModifierNodeName(); newSelList.add( modifierNodeName); MGlobal::setActiveSelectionList( newSelList);//, MGlobal::kAddToList); //################################################################## successResult(); return MStatus::kSuccess; }
MStatus tm_polySplit::doIt( const MArgList& args) { #ifdef _DEBUG cout << endl << "####################################################" << endl; cout << "tm_polySplit::doIt - DEBUG version info:" << endl; #endif MStatus status; MGlobal::getActiveSelectionList( oldSelList ); MArgDatabase argData( syntax(), args); //parse flags // if(argData.isFlagSet( loop_Flag)) { cmd_flag_loop = true; argData.getFlagArgument( loop_Flag, 0, cmd_flag_loop_mode); argData.getFlagArgument( loop_Flag, 1, cmd_flag_loop_angle); // argData.getFlagArgument( loop_Flag, 2, cmd_flag_loop_maxcount); // - max count; } else if(argData.isFlagSet( sel_Flag)) { cmd_flag_loop = false; cmd_flag_sel = true; } MSelectionList selectionList; argData.getObjects( selectionList); MItSelectionList selListIter( selectionList ); selListIter.setFilter( MFn::kMesh ); // The tm_polySplit 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 edgesIds, // 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; MObject meshObj; for( ; !selListIter.isDone(); selListIter.next() ) { MDagPath dagPath; MObject component; selListIter.getDagPath( dagPath, component ); meshObj = dagPath.node(); // Check for selected Edges components // if( component.apiType() == MFn::kMeshEdgeComponent ) { 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 edgesIds of the selected Edges 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 ); compFn.getElements( fSelEdges ); // 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 UVs, since // we are not interested in how many multiple objects there are, only // the fact that there are multiple objects. // foundMultiple = true; break; } } } #ifdef _DEBUG cout << endl << "########################## checking arguments:" << endl; cout << endl << "fSelEdges = ";for(unsigned i=0;i<fSelEdges.length();i++) cout << fSelEdges[i] << " ";cout << endl; #endif if( foundMultiple ) { displayWarning("Found more than one object with selected Edges - Only operating on first found object."); } if( !found ) { displayError( "tm_polySplit command failed: Unable to find selected edges" ); return MStatus::kFailure; } // Initialize the polyModifierCmd node type - mesh node already set // setModifierNodeType( tm_polySplitNode::id ); //################################################################## alwaysWithConstructionHistory = true; status = doModifyPoly(); if( !status){displayError( "tm_polySplit command failed!" );return status;} //################################################################## get polymodifier node name and select it getModifierNodeName(); newSelList.add( modifierNodeName); MGlobal::setActiveSelectionList( newSelList);//, MGlobal::kAddToList); //################################################################## setResult( modifierNodeName); return MStatus::kSuccess; /* cout<<endl<<"**********"<<endl;return MStatus::kSuccess; */ }
bool tm_polyExtract::extractFaces_Func( MSelectionList &selectionList, MStringArray &node_names) { MStatus status; MObject meshObj; status = selectionList.getDependNode( 0, meshObj); if(!status){MGlobal::displayError("tm_polyExtract::extractFaces_Func: Can't find object !");return false;} MFnMesh meshFn( meshObj, &status); if(!status){MGlobal::displayError("tm_polyExtract::extractFaces_Func: Non mesh object founded !");return false;} MDagPath meshDagPath_first, meshDagPath; selectionList.getDagPath( 0, meshDagPath_first); MObject multiFaceComponent; MIntArray inputFacesArray; inputFacesArray.clear(); inputFacesArray.setSizeIncrement( 4096); MFnComponentListData compListFn; compListFn.create(); for (MItSelectionList faceComponentIter(selectionList, MFn::kMeshPolygonComponent); !faceComponentIter.isDone(); faceComponentIter.next()) { faceComponentIter.getDagPath(meshDagPath, multiFaceComponent); if(!(meshDagPath_first == meshDagPath)) { MGlobal::displayError("tm_polyExtract::extractFaces_Func: Different meshes faces founded !"); return false; } if (!multiFaceComponent.isNull()) { for (MItMeshPolygon faceIter(meshDagPath, multiFaceComponent); !faceIter.isDone(); faceIter.next()) { int faceIndex = faceIter.index(); #ifdef _DEBUG infoMStr += faceIndex; infoMStr += " "; #endif inputFacesArray.append( faceIndex); compListFn.add( multiFaceComponent ); } } } if( inputFacesArray.length() == 0) { MGlobal::displayError("tm_polyExtract::extractFaces_Func: No faces founded !"); return false; } #ifdef _DEBUG MGlobal::displayInfo( infoMStr); #endif meshFn.setObject( meshDagPath_first); meshObj = meshFn.object(); // MDagModifier dagModifier; MFnDagNode meshDagNodeFn; MFnDependencyNode depNodeFn; meshDagNodeFn.setObject( meshDagPath_first); MString meshName = meshDagNodeFn.name(); MObject outMesh_attrObject = meshDagNodeFn.attribute( "outMesh"); // ----------------------------------- duplicate shape MObject duplicated_meshObjectA; MObject duplicated_meshObjectB; MObject inMesh_attrObjectA; MObject inMesh_attrObjectB; /* MStringArray commandResult; MSelectionList selList; MGlobal::executeCommand( "duplicate " + meshDagNodeFn.name(), commandResult, 1, 1); selList.add( commandResult[0]); selList.getDependNode( 0, duplicated_meshObjectA); meshDagNodeFn.setObject( duplicated_meshObjectA); meshDagNodeFn.setName( meshName + "_tA"); duplicated_meshObjectA = meshDagNodeFn.child(0); meshDagNodeFn.setObject( duplicated_meshObjectA); meshDagNodeFn.setName( meshName + "_sA"); inMesh_attrObjectA = meshDagNodeFn.attribute( "inMesh"); meshDagNodeFn.setObject( meshDagPath_first); selList.clear(); MGlobal::executeCommand( "duplicate " + meshDagNodeFn.name(), commandResult, 1, 1); selList.add( commandResult[0]); selList.getDependNode( 0, duplicated_meshObjectB); meshDagNodeFn.setObject( duplicated_meshObjectB); meshDagNodeFn.setName( meshName + "_tB"); duplicated_meshObjectB = meshDagNodeFn.child(0); meshDagNodeFn.setObject( duplicated_meshObjectB); meshDagNodeFn.setName( meshName + "_sB"); inMesh_attrObjectB = meshDagNodeFn.attribute( "inMesh"); */ duplicated_meshObjectA = meshDagNodeFn.duplicate(); meshDagNodeFn.setObject( duplicated_meshObjectA); meshDagNodeFn.setName( meshName + "_tA"); duplicated_meshObjectA = meshDagNodeFn.child(0); meshDagNodeFn.setObject( duplicated_meshObjectA); meshDagNodeFn.setName( meshName + "_sA"); inMesh_attrObjectA = meshDagNodeFn.attribute( "inMesh"); meshDagNodeFn.setObject( meshDagPath_first); duplicated_meshObjectB = meshDagNodeFn.duplicate(); meshDagNodeFn.setObject( duplicated_meshObjectB); meshDagNodeFn.setName( meshName + "_tB"); duplicated_meshObjectB = meshDagNodeFn.child(0); meshDagNodeFn.setObject( duplicated_meshObjectB); meshDagNodeFn.setName( meshName + "_sB"); inMesh_attrObjectB = meshDagNodeFn.attribute( "inMesh"); // ----------------------------------- create node deleteComponent MDGModifier dgModifier; MObject deleteComponent_nodeObjectA = dgModifier.createNode( MString("deleteComponent")); depNodeFn.setObject( deleteComponent_nodeObjectA ); MObject deleteComponent_attrObjectA( depNodeFn.attribute( "deleteComponents" )); MObject inputGeometry_attrObjectA( depNodeFn.attribute( "inputGeometry" )); MObject outputGeometry_attrObjectA( depNodeFn.attribute( "outputGeometry" )); dgModifier.doIt(); depNodeFn.setName( "dfA_" + meshName); node_names.append( depNodeFn.name()); MObject deleteComponent_nodeObjectB = dgModifier.createNode( MString("deleteComponent")); depNodeFn.setObject( deleteComponent_nodeObjectB ); MObject deleteComponent_attrObjectB( depNodeFn.attribute( "deleteComponents" )); MObject inputGeometry_attrObjectB( depNodeFn.attribute( "inputGeometry" )); MObject outputGeometry_attrObjectB( depNodeFn.attribute( "outputGeometry" )); dgModifier.doIt(); depNodeFn.setName( "dfB_" + meshName); node_names.append( depNodeFn.name()); // ----------------------------------- set attribute deleteComponent.deleteComponents MObject componentList_object = compListFn.object(); MPlug deleteComponents_plugA( deleteComponent_nodeObjectA, deleteComponent_attrObjectA ); status = deleteComponents_plugA.setValue( componentList_object ); MIntArray invertedFaces; int numPolygons = meshFn.numPolygons(); invertedFaces.setLength( numPolygons - inputFacesArray.length()); int selFace = 0; int invFace = 0; for( int f = 0; f < numPolygons; f++) { if( f == inputFacesArray[selFace]) selFace++; else invertedFaces[invFace++] = f; } MFnSingleIndexedComponent singleIndexedComponentFn( meshObj); singleIndexedComponentFn.create( MFn::kMeshPolygonComponent); singleIndexedComponentFn.addElements( invertedFaces); compListFn.clear(); compListFn.create(); componentList_object = singleIndexedComponentFn.object(); compListFn.add( componentList_object); componentList_object = compListFn.object(); MPlug deleteComponents_plugB( deleteComponent_nodeObjectB, deleteComponent_attrObjectB ); status = deleteComponents_plugB.setValue( componentList_object ); // ------------------------------------- connecting plugs /**/ dgModifier.connect( meshObj, outMesh_attrObject, deleteComponent_nodeObjectA, inputGeometry_attrObjectA ); dgModifier.connect( deleteComponent_nodeObjectA, outputGeometry_attrObjectA, duplicated_meshObjectA, inMesh_attrObjectA ); dgModifier.connect( meshObj, outMesh_attrObject, deleteComponent_nodeObjectB, inputGeometry_attrObjectB ); dgModifier.connect( deleteComponent_nodeObjectB, outputGeometry_attrObjectB, duplicated_meshObjectB, inMesh_attrObjectB ); dgModifier.doIt(); // ---------------------------------- assigning shading group /**/ meshDagNodeFn.setObject( meshDagPath_first); MObject instObjGroups_attrObject = meshDagNodeFn.attribute( "instObjGroups"); MPlug instObjGroups_plug( meshObj, instObjGroups_attrObject); instObjGroups_plug = instObjGroups_plug.elementByPhysicalIndex(0); MPlugArray instObjGroups_plug_connectionsArray; instObjGroups_plug.connectedTo( instObjGroups_plug_connectionsArray, false, true); if( instObjGroups_plug_connectionsArray.length() > 0) { MPlug dagSetMembers_plug = instObjGroups_plug_connectionsArray[0]; MObject shadingSetNode_object = dagSetMembers_plug.node(); MFnSet setFn( shadingSetNode_object); setFn.addMember( duplicated_meshObjectA); setFn.addMember( duplicated_meshObjectB); //depNodeFn.setObject(shadingSetNode_object); //MGlobal::displayInfo( depNodeFn.name()); } // ------------------------------------------------------------ return true; }
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; }