//---------------------------------------------------
MObject DagHelper::createExpression ( const MPlug& plug, const MString& expression )
{
MFnDependencyNode expressionFn;
MObject expressionObj = expressionFn.create ( "expression" );
DagHelper::setPlugValue ( expressionObj, "expression", expression );
MPlug output = expressionFn.findPlug ( "output" );
MPlug firstOutput = output.elementByLogicalIndex ( 0 );
DagHelper::connect ( firstOutput, plug );
return expressionObj;
}
//---------------------------------------------------
MObject DagHelper::createAnimationCurve ( const MPlug& plug, const char* curveType )
{
MStatus rc;
MFnDependencyNode curveFn;
curveFn.create ( curveType, &rc );
if ( rc == MStatus::kSuccess )
{
DagHelper::connect ( curveFn.object(), "output", plug );
}
return curveFn.object();
}
void NifTextureConnector::ConnectTexture( MDagPath mesh_path ) {
MDGModifier dgModifier;
MFnDependencyNode chooserFn;
chooserFn.create( "uvChooser", "uvChooser" );
//Connection between the mesh and the uvChooser
MFnMesh meshFn;
meshFn.setObject(mesh_path);
dgModifier.connect( meshFn.findPlug("uvSet")[uvSet].child(0), chooserFn.findPlug("uvSets").elementByLogicalIndex(0) );
//Connections between the uvChooser and the place2dTexture
dgModifier.connect( chooserFn.findPlug("outUv"), texturePlacement.findPlug("uvCoord") );
dgModifier.connect( chooserFn.findPlug("outVertexCameraOne"), texturePlacement.findPlug("vertexCameraOne") );
dgModifier.connect( chooserFn.findPlug("outVertexUvOne"), texturePlacement.findPlug("vertexUvOne") );
dgModifier.connect( chooserFn.findPlug("outVertexUvTwo"), texturePlacement.findPlug("vertexUvTwo") );
dgModifier.connect( chooserFn.findPlug("outVertexUvThree"), texturePlacement.findPlug("vertexUvThree") );
dgModifier.doIt();
}
MStatus testExCameraSetCmd::doIt( const MArgList& args)
//
// Parses the given command line arguments and executes them.
//
{
MStatus status = parseArgs(args);
if (status != MS::kSuccess)
{
MGlobal::displayError("Error parsing argument list");
return status;
}
bool nothingSet = ( !createUsed && !appendCameraUsed && !appendCameraAndSetUsed && !deleteLayerUsed && !cameraUsed &&
!layerUsed && !helpUsed && !setUsed && !layerTypeUsed && !numLayersUsed);
if (nothingSet)
{
MGlobal::displayError("A flag must be used. testCameraSet -help for availible flags.");
return MS::kFailure;
}
if (helpUsed) {
MGlobal::displayInfo("testExCameraSet -help");
MGlobal::displayInfo("\ttestExCameraSet tests the functionality of the exCameraSet node.");
MGlobal::displayInfo("");
MGlobal::displayInfo("\t-h -help : This message is printed");
MGlobal::displayInfo("\t-a -active [true/false]: Set/get whether a particular layer is active");
MGlobal::displayInfo("\t-ac -appendCamera <cameraName>: Append a new camera layer to the cameraSet using the specified camera");
MGlobal::displayInfo("\t-acs -appendCameraAndSet <cameraName> <setName>: Append a new camera layer to the cameraSet using the specified camera and set");
MGlobal::displayInfo("\t-cam -camera [<cameraName>]: Set/get the camera for a particular layer");
MGlobal::displayInfo("\t-c -create : Create a new cameraSet node");
MGlobal::displayInfo("\t-d -deleteLayer <layerIndex>: Delete the layer at the given index");
MGlobal::displayInfo("\t-nl -numLayers: Returns the number of layers defined in the specified cameraSet");
MGlobal::displayInfo("\t-l -layer <layerIndex>: Specifies the layer index to be used when accessing layer information");
MGlobal::displayInfo("\t-lt -layerType [<layerTypeName>]: Set/get the layer type for a particular layer. Possible values are Mono, Left, and Right.");
MGlobal::displayInfo("\t-s -set [<setName>]: Set/get the set for a particular layer");
MGlobal::displayInfo("\t-e -edit : Perform an edit operation");
MGlobal::displayInfo("\t-q -query : Perform a query operation");
MGlobal::displayInfo("");
}
unsigned nObjs = list.length();
if (nObjs == 0)
{
if (createUsed)
{
// Create a new cameraSet node.
MFnDependencyNode dirFn;
MString noName;
MObject dirObj = dirFn.create(exCameraSet::id, noName, &status);
if (!status)
{
MGlobal::displayError("Could not create a cameraSet node");
return status;
}
MGlobal::select(dirObj, MGlobal::kReplaceList);
return status;
}
if (appendCameraUsed || appendCameraAndSetUsed || deleteLayerUsed || editUsed || cameraUsed ||
setUsed || layerTypeUsed || activeUsed || numLayersUsed) {
MGlobal::displayError("Must specify a cameraSet node");
status = MS::kFailure;
return status;
}
}
else
{
if (createUsed)
{
MGlobal::displayError("-create cannot have any object specifed");
status = MS::kFailure;
return status;
}
if (appendCameraUsed)
{
if (nObjs != 1)
{
MGlobal::displayError("-appendCamera must have a single cameraSet node specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-appendCamera must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
// Get a dag path to the specified camera.
MSelectionList camList;
camList.add(camName);
MDagPath camPath;
camList.getDagPath(0, camPath);
if (!camPath.isValid())
{
MGlobal::displayError("-appendCamera must have a valid camera node specified");
status = MS::kFailure;
return status;
}
// Call the MFnCameraSet method to append the layer.
MFnCameraSet dirFn(dirNode);
dirFn.appendLayer(camPath, MObject::kNullObj);
return status;
}
if (appendCameraAndSetUsed)
{
if (nObjs != 1)
{
MGlobal::displayError("-appendCameraAndSet must have a single cameraSet node specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-appendCameraAndSet must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
// Get a dag path to the specified camera.
MSelectionList camList;
camList.add(camName);
MDagPath camPath;
camList.getDagPath(0, camPath);
if (!camPath.isValid())
{
MGlobal::displayError("-appendCameraAndSet must have a valid camera node specified");
status = MS::kFailure;
return status;
}
// Get the specified set node.
MSelectionList setList;
setList.add(setName);
MObject setObj = MObject::kNullObj;
setList.getDependNode(0, setObj);
if (setObj == MObject::kNullObj)
{
MGlobal::displayError("-appendCameraAndSet must have a valid set node specified");
status = MS::kFailure;
return status;
}
// Call the MFnCameraSet method to append the layer.
MFnCameraSet dirFn(dirNode);
dirFn.appendLayer(camPath, setObj);
return status;
}
if (deleteLayerUsed)
{
if (nObjs != 1)
{
MGlobal::displayError("-deleteLayer must have a single cameraSet node specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-deleteLayer must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
// Call the MFnCameraSet method to delete the layer.
MFnCameraSet dirFn(dirNode);
dirFn.deleteLayer(cameraLayer);
return status;
}
if (numLayersUsed)
{
if (queryUsed)
{
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-numLayers must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
// Call the MFnCameraSet method to get the number of layers.
MFnCameraSet dirFn(dirNode);
unsigned int numLayers = dirFn.getNumLayers(&status);
if (status != MS::kSuccess)
MGlobal::displayError("Error getting the number of layers");
setResult((int)numLayers);
}
else
{
MGlobal::displayError("-numLayers requires the query flag to be used");
status = MS::kFailure;
}
return status;
}
if (cameraUsed)
{
if ((nObjs != 1) || (!layerUsed))
{
MGlobal::displayError("-camera must have a cameraSet node and layer specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-camera must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
if (editUsed)
{
// Get a dag path to the specified camera.
MSelectionList camList;
camList.add(camName);
MDagPath camPath;
camList.getDagPath(0, camPath);
if (!camPath.isValid())
{
MGlobal::displayError("-camera must have a valid camera node specified");
status = MS::kFailure;
return status;
}
// Call the MFnCameraSet method to set the camera.
MFnCameraSet dirFn(dirNode);
dirFn.setLayerCamera((unsigned int)cameraLayer, camPath);
}
else if (queryUsed)
{
// Call the MFnCameraSet method to get the camera.
MDagPath camPath;
MFnCameraSet dirFn(dirNode);
status = dirFn.getLayerCamera((unsigned int)cameraLayer, camPath);
if (status == MS::kSuccess)
{
MObject camNode = camPath.node();
MFnDependencyNode nodeFn(camNode);
setResult(nodeFn.name());
}
else
setResult("");
}
}
if (setUsed)
{
if ((nObjs != 1) || (!layerUsed))
{
MGlobal::displayError("-set must have a cameraSet node and layer specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-set must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
if (editUsed)
{
// Get the specified set node.
MObject setObj = MObject::kNullObj;
if (setName != "")
{
MSelectionList setList;
setList.add(setName);
setList.getDependNode(0, setObj);
if (setObj == MObject::kNullObj)
{
MGlobal::displayError("-set must have a valid set node specified");
status = MS::kFailure;
return status;
}
}
// Call the MFnCameraSet method to set the set node.
MFnCameraSet dirFn(dirNode);
dirFn.setLayerSceneData((unsigned int)cameraLayer, setObj);
}
else if (queryUsed)
{
// Call the MFnCameraSet method to get the set node.
MObject setObj;
MFnCameraSet dirFn(dirNode);
status = dirFn.getLayerSceneData((unsigned int)cameraLayer, setObj);
if (status == MS::kSuccess)
{
MFnDependencyNode nodeFn(setObj);
setResult(nodeFn.name());
}
else
setResult("");
}
}
if (layerTypeUsed)
{
if ((nObjs != 1) || (!layerUsed))
{
MGlobal::displayError("-layerType must have a cameraSet node and layer specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-layerType must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
MFnDependencyNode nodeFn(dirNode);
exCameraSet *exDir = (exCameraSet *)nodeFn.userNode();
if (editUsed)
{
// Get the specified layer type.
int pt = -1;
if (layerTypeVal == "Mono")
pt = 0;
else if (layerTypeVal == "Left")
pt = 1;
else if (layerTypeVal == "Right")
pt = 2;
else
{
MGlobal::displayError("-layerType must have a valid type specified");
status = MS::kFailure;
return status;
}
// Call the exCameraSet method to set the layer type.
exDir->setLayerType((unsigned int)cameraLayer, pt);
}
else if (queryUsed)
{
// Call the exCameraSet method to get the layer type.
int lt;
status = exDir->getLayerType((unsigned int)cameraLayer, lt);
if (status == MS::kSuccess)
{
if (lt == 0)
setResult("Mono");
else if (lt == 1)
setResult("Left");
else if (lt == 2)
setResult("Right");
}
else
{
MGlobal::displayError("exCameraSet node does not have a valid layer type");
status = MS::kFailure;
return status;
}
}
}
if (activeUsed)
{
if ((nObjs != 1) || (!layerUsed))
{
MGlobal::displayError("-active must have a cameraSet node and layer specified");
status = MS::kFailure;
return status;
}
// Get the specified cameraSet node.
MObject dirNode = MObject::kNullObj;
if (!getExCameraSetNode(dirNode))
{
MGlobal::displayError("-active must have a valid exCameraSet node specified");
status = MS::kFailure;
return status;
}
if (editUsed)
{
// Call the MFnCameraSet method to set the set node.
MFnCameraSet dirFn(dirNode);
dirFn.setLayerActive((unsigned int)cameraLayer, activeVal);
}
else if (queryUsed)
{
// Call the MFnCameraSet method to get the active value.
MStatus stat = MS::kSuccess;
MFnCameraSet dirFn(dirNode);
activeVal = dirFn.isLayerActive((unsigned int)cameraLayer, &stat);
if (stat == MS::kSuccess)
setResult(activeVal);
else
MGlobal::displayError("Could not get active value");
}
}
}
return status;
}
MStatus closestPointOnCurveCommand::redoIt()
{
// DOUBLE-CHECK TO MAKE SURE THERE'S A SPECIFIED OBJECT TO EVALUATE ON:
if (sList.length() == 0)
{
MStatus stat;
MString msg = MStringResource::getString(kNoValidObject, stat);
displayError(msg);
return MStatus::kFailure;
}
// RETRIEVE THE SPECIFIED OBJECT AS A DAGPATH:
MDagPath curveDagPath;
sList.getDagPath(0, curveDagPath);
// CHECK FOR INVALID NODE-TYPE INPUT WHEN SPECIFIED/SELECTED NODE IS *NOT* A "CURVE" NOR "CURVE TRANSFORM":
if (!curveDagPath.node().hasFn(MFn::kNurbsCurve) && !(curveDagPath.node().hasFn(MFn::kTransform) && curveDagPath.hasFn(MFn::kNurbsCurve)))
{
MStatus stat;
MString msg;
// Use format to place variable string into message
MString msgFmt = MStringResource::getString(kInvalidType, stat);
MStringArray selectionStrings;
sList.getSelectionStrings(0, selectionStrings);
msg.format(msgFmt, selectionStrings[0]);
displayError(msg);
return MStatus::kFailure;
}
// WHEN COMMAND *NOT* IN "QUERY MODE" (I.E. "CREATION MODE"), CREATE AND CONNECT A "closestPointOnCurve" NODE AND RETURN ITS NODE NAME:
if (!queryFlagSet)
{
// CREATE THE NODE:
MFnDependencyNode depNodeFn;
if (closestPointOnCurveNodeName == "")
depNodeFn.create("closestPointOnCurve");
else
depNodeFn.create("closestPointOnCurve", closestPointOnCurveNodeName);
closestPointOnCurveNodeName = depNodeFn.name();
// SET THE ".inPosition" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (inPositionFlagSet)
{
MPlug inPositionXPlug = depNodeFn.findPlug("inPositionX");
inPositionXPlug.setValue(inPosition.x);
MPlug inPositionYPlug = depNodeFn.findPlug("inPositionY");
inPositionYPlug.setValue(inPosition.y);
MPlug inPositionZPlug = depNodeFn.findPlug("inPositionZ");
inPositionZPlug.setValue(inPosition.z);
}
// MAKE SOME ADJUSTMENTS WHEN THE SPECIFIED NODE IS A "TRANSFORM" OF A CURVE SHAPE:
unsigned instanceNumber=0;
if (curveDagPath.node().hasFn(MFn::kTransform))
{
// EXTEND THE DAGPATH TO ITS CURVE "SHAPE" NODE:
curveDagPath.extendToShape();
// TRANSFORMS ARE *NOT* NECESSARILY THE "FIRST" INSTANCE TRANSFORM OF A CURVE SHAPE:
instanceNumber = curveDagPath.instanceNumber();
}
// CONNECT THE NODES:
MPlug worldCurvePlug, inCurvePlug;
inCurvePlug = depNodeFn.findPlug("inCurve");
depNodeFn.setObject(curveDagPath.node());
worldCurvePlug = depNodeFn.findPlug("worldSpace");
worldCurvePlug = worldCurvePlug.elementByLogicalIndex(instanceNumber);
MDGModifier dgModifier;
dgModifier.connect(worldCurvePlug, inCurvePlug);
dgModifier.doIt();
// SET COMMAND RESULT TO BE NEW NODE'S NAME, AND RETURN:
setResult(closestPointOnCurveNodeName);
return MStatus::kSuccess;
}
// OTHERWISE, WE'RE IN THE COMMAND'S "QUERY MODE":
else
{
// COMPUTE THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE, USING THE *FIRST* INSTANCE TRANSFORM WHEN CURVE IS SPECIFIED AS A "SHAPE":
MPoint position;
MVector normal, tangent;
double paramU, distance;
closestTangentUAndDistance(curveDagPath, inPosition, position, normal, tangent, paramU, distance);
// WHEN NO QUERYABLE FLAG IS SPECIFIED, INDICATE AN ERROR:
if (!positionFlagSet && !normalFlagSet && !tangentFlagSet && !paramUFlagSet && !distanceFlagSet)
{
MStatus stat;
MString msg = MStringResource::getString(kNoQueryFlag, stat);
displayError(msg);
return MStatus::kFailure;
}
// WHEN JUST THE "DISTANCE" IS QUERIED, RETURN A SINGLE "FLOAT" INSTEAD OF AN ENTIRE FLOAT ARRAY FROM THE COMMAND:
else if (distanceFlagSet && !(positionFlagSet || normalFlagSet || tangentFlagSet || paramUFlagSet))
setResult(distance);
// WHEN JUST THE "PARAMETER-U" IS QUERIED, RETURN A SINGLE "FLOAT" INSTEAD OF AN ENTIRE FLOAT ARRAY FROM THE COMMAND:
else if (paramUFlagSet && !(positionFlagSet || normalFlagSet || tangentFlagSet || distanceFlagSet))
setResult(paramU);
// OTHERWISE, SET THE RETURN VALUE OF THE COMMAND'S RESULT TO A "COMPOSITE ARRAY OF FLOATS":
else
{
// HOLDS FLOAT ARRAY RESULT:
MDoubleArray floatArrayResult;
// APPEND THE RESULTS OF THE CLOSEST POSITION, NORMAL, TANGENT, PARAMETER-U AND DISTANCE VALUES TO THE FLOAT ARRAY RESULT:
if (positionFlagSet)
{
floatArrayResult.append(position.x);
floatArrayResult.append(position.y);
floatArrayResult.append(position.z);
}
if (normalFlagSet)
{
floatArrayResult.append(normal.x);
floatArrayResult.append(normal.y);
floatArrayResult.append(normal.z);
}
if (tangentFlagSet)
{
floatArrayResult.append(tangent.x);
floatArrayResult.append(tangent.y);
floatArrayResult.append(tangent.z);
}
if (paramUFlagSet)
floatArrayResult.append(paramU);
if (distanceFlagSet)
floatArrayResult.append(distance);
// FINALLY, SET THE COMMAND'S RESULT:
setResult(floatArrayResult);
}
return MStatus::kSuccess;
}
}
MStatus pointOnMeshCommand::redoIt()
{
// WHEN NO MESH IS SPECIFIED IN THE COMMAND, GET THE FIRST SELECTED MESH FROM THE SELECTION LIST:
MSelectionList sList;
if (meshNodeName=="")
{
MGlobal::getActiveSelectionList(sList);
if (sList.length()==0)
{
displayError("No mesh or mesh transform specified!");
return MS::kFailure;
}
}
// OTHERWISE, USE THE NODE NAME SPECIFIED IN THE LAST ARGUMENT OF THE COMMAND:
else if (sList.add(meshNodeName) == MS::kInvalidParameter)
{
displayError("Specified mesh does not exist!");
return MS::kFailure;
}
// RETRIEVE THE FIRST ITEM FROM THE SELECTION LIST:
MDagPath meshDagPath;
sList.getDagPath(0, meshDagPath);
// CREATE AND CONNECT A "pointOnMeshInfo" NODE, OR GET THE POINT AND NORMAL ACCORDING TO
// WHETHER THE "-position/-p" AND/OR "-normal/-nr" FLAGS WERE SPECIFIED, AND WHETHER THE MESH
// "SHAPE" OR ITS "TRANSFORM" WAS SPECIFIED/SELECTED:
MPoint point;
MVector normal;
// WHEN THE SPECIFIED NODE IS THE MESH "SHAPE":
if (meshDagPath.node().hasFn(MFn::kMesh))
{
// WHEN NEITHER "-position/-p" NOR "-normal/-nr" ARE SPECIFIED, CREATE AND CONNECT A "pointOnMeshInfo" NODE AND RETURN ITS NODE NAME:
if (!positionSpecified && !normalSpecified)
{
// CREATE THE NODE:
nodeCreated = true;
MFnDependencyNode depNodeFn;
if (pointOnMeshInfoName == "")
depNodeFn.create("pointOnMeshInfo");
else
depNodeFn.create("pointOnMeshInfo", pointOnMeshInfoName);
pointOnMeshInfoName = depNodeFn.name();
// SET THE ".faceIndex" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (faceIndexSpecified)
{
MPlug faceIndexPlug = depNodeFn.findPlug("faceIndex");
faceIndexPlug.setValue(faceIndex);
}
// SET THE ".relative" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (relativeSpecified)
{
MPlug relativePlug = depNodeFn.findPlug("relative");
relativePlug.setValue(relative);
}
// SET THE ".parameterU" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (parameterUSpecified)
{
MPlug parameterUPlug = depNodeFn.findPlug("parameterU");
parameterUPlug.setValue(parameterU);
}
// SET THE ".parameterV" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (parameterVSpecified)
{
MPlug parameterVPlug = depNodeFn.findPlug("parameterV");
parameterVPlug.setValue(parameterV);
}
// CONNECT THE NODES:
MPlug worldMeshPlug, inMeshPlug;
inMeshPlug = depNodeFn.findPlug("inMesh");
depNodeFn.setObject(meshDagPath.node());
worldMeshPlug = depNodeFn.findPlug("worldMesh");
worldMeshPlug = worldMeshPlug.elementByLogicalIndex(0); // ASSUME THE *FIRST* INSTANCE OF THE MESH IS REQUESTED FOR MESH SHAPES.
MDGModifier dgModifier;
dgModifier.connect(worldMeshPlug, inMeshPlug);
dgModifier.doIt();
// SET COMMAND RESULT AND RETURN:
setResult(pointOnMeshInfoName);
return MStatus::kSuccess;
}
// OTHERWISE, COMPUTE THE POINT-POSITION AND NORMAL, USING THE *FIRST* INSTANCE'S TRANSFORM:
else
getPointAndNormal(meshDagPath, faceIndex, relative, parameterU, parameterV, point, normal);
}
// WHEN THE SPECIFIED NODE IS A "TRANSFORM" OF A MESH SHAPE:
else if (meshDagPath.node().hasFn(MFn::kTransform) && meshDagPath.hasFn(MFn::kMesh))
{
// WHEN NEITHER "-position/-p" NOR "-normal/-nr" ARE SPECIFIED, CREATE AND CONNECT A "pointOnMeshInfo" NODE AND RETURN ITS NODE NAME:
if (!positionSpecified && !normalSpecified)
{
// CREATE THE NODE:
nodeCreated = true;
meshDagPath.extendToShape();
MFnDependencyNode depNodeFn;
if (pointOnMeshInfoName == "")
depNodeFn.create("pointOnMeshInfo");
else
depNodeFn.create("pointOnMeshInfo", pointOnMeshInfoName);
pointOnMeshInfoName = depNodeFn.name();
// SET THE ".faceIndex" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (faceIndexSpecified)
{
MPlug faceIndexPlug = depNodeFn.findPlug("faceIndex");
faceIndexPlug.setValue(faceIndex);
}
// SET THE ".relative" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (relativeSpecified)
{
MPlug relativePlug = depNodeFn.findPlug("relative");
relativePlug.setValue(relative);
}
// SET THE ".parameterU" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (parameterUSpecified)
{
MPlug parameterUPlug = depNodeFn.findPlug("parameterU");
parameterUPlug.setValue(parameterU);
}
// SET THE ".parameterV" ATTRIBUTE, IF SPECIFIED IN THE COMMAND:
if (parameterVSpecified)
{
MPlug parameterVPlug = depNodeFn.findPlug("parameterV");
parameterVPlug.setValue(parameterV);
}
// CONNECT THE NODES:
MPlug worldMeshPlug, inMeshPlug;
inMeshPlug = depNodeFn.findPlug("inMesh");
depNodeFn.setObject(meshDagPath.node());
worldMeshPlug = depNodeFn.findPlug("worldMesh");
worldMeshPlug = worldMeshPlug.elementByLogicalIndex(meshDagPath.instanceNumber());
MDGModifier dgModifier;
dgModifier.connect(worldMeshPlug, inMeshPlug);
dgModifier.doIt();
// SET COMMAND RESULT AND RETURN:
setResult(pointOnMeshInfoName);
return MStatus::kSuccess;
}
// OTHERWISE, COMPUTE THE POINT-POSITION AND NORMAL:
else
getPointAndNormal(meshDagPath, faceIndex, relative, parameterU, parameterV, point, normal);
}
// INVALID INPUT WHEN SPECIFIED/SELECTED NODE IS NOT A MESH NOR TRANSFORM:
else
{
displayError("Invalid type! Only a mesh or its transform can be specified!");
return MStatus::kFailure;
}
// SET THE RETURN VALUES OF THE COMMAND'S RESULT TO BE AN ARRAY OF FLOATS OUTPUTTING THE POSITION AND/OR NORMAL:
MDoubleArray result;
if (positionSpecified)
{
result.append(point.x);
result.append(point.y);
result.append(point.z);
}
if (normalSpecified)
{
result.append(normal.x);
result.append(normal.y);
result.append(normal.z);
}
setResult(result);
return MStatus::kSuccess;
}
