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