//- This function is responsible to make the connection (association)
//- between manipulators and the affected attributes. When a node in a scene
//- is selected and user click on “show manipulator tool”,
//- this function is called with the selected node.
//- Arguments:
//- dependNode - the node which is selected
MStatus arrowLocatorManip::connectToDependNode(const MObject &dependNode)
{
MStatus status = MStatus::kSuccess;
//- Find the "windDirection" plug on the selected node, which is the custom
//- locator node.
MFnDependencyNode fnDepNode(dependNode);
MPlug rotationPlug = fnDepNode.findPlug(MString("windDirection"),&status);
//- Connect the "windDirection" plug with the base disc manip
MFnDiscManip fnDisc(fDiscManip,&status);
status = fnDisc.connectToAnglePlug(rotationPlug);
//- Set up affecting relationship using conversion callback function
//- We are using addPlugToManipConversionCallback so that whenever
//- the custom locator moves, the dis manip moves with it.
MFnDagNode fnDagNode(dependNode);
fnDagNode.getPath(fNodePath);
unsigned int centerPointIndex = fnDisc.centerIndex(&status);
addPlugToManipConversionCallback(centerPointIndex,(plugToManipConversionCallback)&arrowLocatorManip::centerPointCallback);
//- The following two functions are mandatory inside your
//- connectToDependNode() function
status = finishAddingManips();
status = MPxManipContainer::connectToDependNode(dependNode);
return status;
}
//------------------------------------------------------------
MStatus moveManip::connectToDependNode(const MObject &node)
//------------------------------------------------------------
{
MStatus stat;
// Connect the plugs
//
//für späteres onScreenGl
view = M3dView::active3dView();
MFnDependencyNode nodeFn(node,&stat);
if(stat == MS::kFailure)stat.perror("Fehler bei depNode: ");
MPlug tPlug = nodeFn.findPlug("endPoint", &stat);
if(stat == MS::kFailure)stat.perror("Fehler bei tPlug: ");
MFnFreePointTriadManip freePointManipFn(fFreePointManip);
//transFn initialisieren
transFn.setObject(fFreePointManip);
stat = freePointManipFn.connectToPointPlug(tPlug);
if(stat == MS::kFailure)stat.perror("Fehler bei connectToPlug: ");
freePointIndex = freePointManipFn.pointIndex();
/*
translatePlugIndex = addManipToPlugConversionCallback(tPlug,
(manipToPlugConversionCallback)
&moveManip::moveOthersCB);
/*
addPlugToManipConversionCallback(freePointManipFn.pointIndex(),
(plugToManipConversionCallback)
&moveManip::moveOthersCBReverse);
*/
MPlug togglePlug = nodeFn.findPlug("fv");
MFnToggleManip toggleFn(fToggleManip);
toggleFn.connectToTogglePlug(togglePlug);
toggleFn.setLength(0.0);
addPlugToManipConversionCallback(toggleFn.startPointIndex(),
(plugToManipConversionCallback)
&moveManip::setPointCB2);
INVIS(cout<<freePointIndex<<" = freePointIndex "<<endl;)
MStatus swissArmyLocatorManip::connectToDependNode(const MObject &node)
{
MStatus stat;
// Get the DAG path
//
MFnDagNode dagNodeFn(node);
dagNodeFn.getPath(fNodePath);
MObject parentNode = dagNodeFn.parent(0);
MFnDagNode parentNodeFn(parentNode);
// Connect the plugs
//
MFnDependencyNode nodeFn;
nodeFn.setObject(node);
// FreePointTriadManip
//
MFnFreePointTriadManip freePointTriadManipFn(fFreePointTriadManip);
MPlug translationPlug = parentNodeFn.findPlug("t", &stat);
if (MStatus::kFailure != stat) {
freePointTriadManipFn.connectToPointPlug(translationPlug);
}
// DirectionManip
//
MFnDirectionManip directionManipFn;
directionManipFn.setObject(fDirectionManip);
MPlug directionPlug = nodeFn.findPlug("arrow2Direction", &stat);
if (MStatus::kFailure != stat) {
directionManipFn.connectToDirectionPlug(directionPlug);
unsigned startPointIndex = directionManipFn.startPointIndex();
addPlugToManipConversionCallback(startPointIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// DistanceManip
//
MFnDistanceManip distanceManipFn;
distanceManipFn.setObject(fDistanceManip);
MPlug sizePlug = nodeFn.findPlug("size", &stat);
if (MStatus::kFailure != stat) {
distanceManipFn.connectToDistancePlug(sizePlug);
unsigned startPointIndex = distanceManipFn.startPointIndex();
addPlugToManipConversionCallback(startPointIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// CircleSweepManip
//
MFnCircleSweepManip circleSweepManipFn(fCircleSweepManip);
MPlug arrow1AnglePlug = nodeFn.findPlug("arrow1Angle", &stat);
if (MStatus::kFailure != stat) {
circleSweepManipFn.connectToAnglePlug(arrow1AnglePlug);
unsigned centerIndex = circleSweepManipFn.centerIndex();
addPlugToManipConversionCallback(centerIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// DiscManip
//
MFnDiscManip discManipFn(fDiscManip);
MPlug arrow3AnglePlug = nodeFn.findPlug("arrow3Angle", &stat);
if (MStatus::kFailure != stat) {
discManipFn.connectToAnglePlug(arrow3AnglePlug);
unsigned centerIndex = discManipFn.centerIndex();
addPlugToManipConversionCallback(centerIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// StateManip
//
MFnStateManip stateManipFn(fStateManip);
MPlug statePlug = nodeFn.findPlug("state", &stat);
if (MStatus::kFailure != stat) {
stateManipFn.connectToStatePlug(statePlug);
unsigned positionIndex = stateManipFn.positionIndex();
addPlugToManipConversionCallback(positionIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// ToggleManip
//
MFnToggleManip toggleManipFn(fToggleManip);
MPlug togglePlug = nodeFn.findPlug("toggle", &stat);
if (MStatus::kFailure != stat) {
toggleManipFn.connectToTogglePlug(togglePlug);
unsigned startPointIndex = toggleManipFn.startPointIndex();
addPlugToManipConversionCallback(startPointIndex,
(plugToManipConversionCallback)
&swissArmyLocatorManip::startPointCallback);
}
// Determine the transform node for the locator
//
MDagPath transformPath(fNodePath);
transformPath.pop();
MFnTransform transformNode(transformPath);
// RotateManip
//
MFnRotateManip rotateManipFn(fRotateManip);
MPlug rotatePlug = transformNode.findPlug("rotate", &stat);
if (MStatus::kFailure != stat) {
rotateManipFn.connectToRotationPlug(rotatePlug);
rotateManipFn.displayWithNode(node);
}
// ScaleManip
//
MFnScaleManip scaleManipFn(fScaleManip);
MPlug scalePlug = transformNode.findPlug("scale", &stat);
if (MStatus::kFailure != stat) {
scaleManipFn.connectToScalePlug(scalePlug);
scaleManipFn.displayWithNode(node);
}
finishAddingManips();
MPxManipContainer::connectToDependNode(node);
return stat;
}
