public override void createChildren() { // Add the rotation manip // fRotateManip = addRotateManip("RotateManip", "rotation"); // Add the state manip. The state manip is used to cycle through the // rotate manipulator modes to demonstrate how they work. // fStateManip = addStateManip("StateManip", "state"); // The state manip permits 4 states. These correspond to: // 0 - Rotate manip in objectSpace mode // 1 - Rotate manip in worldSpace mode // 2 - Rotate manip in gimbal mode // 3 - Rotate manip in objectSpace mode with snapping on // // Note that while the objectSpace and gimbal modes will operator similar // to the built-in Maya rotate manipulator, the worldSpace mode will // produce unusual rotations because the plugin does not convert worldSpace // rotations to object space. // MFnStateManip stateManip = new MFnStateManip(fStateManip); stateManip.maxStates = 4; stateManip.setInitialState(0); }
public override void connectToDependNode(MObject node) { // Find the rotate and rotatePivot plugs on the node. These plugs will // be attached either directly or indirectly to the manip values on the // rotate manip. // MFnDependencyNode nodeFn = new MFnDependencyNode(node); MPlug rPlug = nodeFn.findPlug("rotate"); MPlug rcPlug = nodeFn.findPlug("rotatePivot"); // If the translate pivot exists, it will be used to move the state manip // to a convenient location. // MPlug tPlug = nodeFn.findPlug("translate"); // To avoid having the object jump back to the default rotation when the // manipulator is first used, extract the existing rotation from the node // and set it as the initial rotation on the manipulator. // MEulerRotation existingRotation = new MEulerRotation(vectorPlugValue(rPlug)); MVector existingTranslation = new MVector(vectorPlugValue(tPlug)); // // The following code configures default settings for the rotate // manipulator. // MFnRotateManip rotateManip = new MFnRotateManip(fRotateManip); rotateManip.setInitialRotation(existingRotation); rotateManip.setRotateMode(MFnRotateManip.RotateMode.kObjectSpace); rotateManip.displayWithNode(node); // Add a callback function to be called when the rotation value changes // //rotatePlugIndex = addManipToPlugConversionCallback( rPlug, (manipToPlugConversionCallback)&exampleRotateManip::rotationChangedCallback ); ManipToPlugConverion[rPlug] = rotationChangedCallback; // get the index of plug rotatePlugIndex = this[rPlug]; // Create a direct (1-1) connection to the rotation center plug // rotateManip.connectToRotationCenterPlug(rcPlug); // Place the state manip at a distance of 2.0 units away from the object // along the X-axis. // MFnStateManip stateManip = new MFnStateManip(fStateManip); MVector delta = new MVector(2, 0, 0); stateManip.setTranslation(existingTranslation + delta, MSpace.Space.kTransform); finishAddingManips(); base.connectToDependNode(node); }
// Callback function MManipData rotationChangedCallback(object sender, ManipConversionArgs args) { MObject obj = MObject.kNullObj; // If we entered the callback with an invalid index, print an error and // return. Since we registered the callback only for one plug, all // invocations of the callback should be for that plug. // MFnNumericData numericData = new MFnNumericData(); if (args.ManipIndex != rotatePlugIndex) { MGlobal.displayError("Invalid index in rotation changed callback!"); // For invalid indices, return vector of 0's obj = numericData.create(MFnNumericData.Type.k3Double); numericData.setData(0.0, 0.0, 0.0); return new MManipData(obj); } // Assign function sets to the manipulators // MFnStateManip stateManip = new MFnStateManip(fStateManip); MFnRotateManip rotateManip = new MFnRotateManip(fRotateManip); // Adjust settings on the rotate manip based on the state of the state // manip. // uint mode = stateManip.state; if (mode != 3) { rotateManip.setRotateMode((MFnRotateManip.RotateMode)stateManip.state); rotateManip.setSnapMode(false); } else { // State 3 enables snapping for an object space manip. In this case, // we snap every 15.0 degrees. // rotateManip.setRotateMode(MFnRotateManip.RotateMode.kObjectSpace); rotateManip.setSnapMode(true); rotateManip.snapIncrement = 15.0; } // The following code creates a data object to be returned in the // MManipData. In this case, the plug to be computed must be a 3-component // vector, so create data as MFnNumericData::k3Double // obj = numericData.create(MFnNumericData.Type.k3Double); // Retrieve the value for the rotation from the manipulator and return it // directly without modification. If the manipulator should eg. slow down // rotation, this method would need to do some math with the value before // returning it. // MEulerRotation manipRotation = new MEulerRotation(); try { getConverterManipValue(rotateManip.rotationIndex, manipRotation); numericData.setData(manipRotation.x, manipRotation.y, manipRotation.z); } catch (System.Exception) { MGlobal.displayError("Error retrieving manip value"); numericData.setData(0.0, 0.0, 0.0); } return new MManipData(obj); }
// Callback function MManipData rotationChangedCallback(object sender, ManipConversionArgs args) { MObject obj = MObject.kNullObj; // If we entered the callback with an invalid index, print an error and // return. Since we registered the callback only for one plug, all // invocations of the callback should be for that plug. // MFnNumericData numericData = new MFnNumericData(); if (args.ManipIndex != rotatePlugIndex) { MGlobal.displayError("Invalid index in rotation changed callback!"); // For invalid indices, return vector of 0's obj = numericData.create(MFnNumericData.Type.k3Double); numericData.setData(0.0, 0.0, 0.0); return(new MManipData(obj)); } // Assign function sets to the manipulators // MFnStateManip stateManip = new MFnStateManip(fStateManip); MFnRotateManip rotateManip = new MFnRotateManip(fRotateManip); // Adjust settings on the rotate manip based on the state of the state // manip. // uint mode = stateManip.state; if (mode != 3) { rotateManip.setRotateMode((MFnRotateManip.RotateMode)stateManip.state); rotateManip.setSnapMode(false); } else { // State 3 enables snapping for an object space manip. In this case, // we snap every 15.0 degrees. // rotateManip.setRotateMode(MFnRotateManip.RotateMode.kObjectSpace); rotateManip.setSnapMode(true); rotateManip.snapIncrement = 15.0; } // The following code creates a data object to be returned in the // MManipData. In this case, the plug to be computed must be a 3-component // vector, so create data as MFnNumericData::k3Double // obj = numericData.create(MFnNumericData.Type.k3Double); // Retrieve the value for the rotation from the manipulator and return it // directly without modification. If the manipulator should eg. slow down // rotation, this method would need to do some math with the value before // returning it. // MEulerRotation manipRotation = new MEulerRotation(); try { getConverterManipValue(rotateManip.rotationIndex, manipRotation); numericData.setData(manipRotation.x, manipRotation.y, manipRotation.z); } catch (System.Exception) { MGlobal.displayError("Error retrieving manip value"); numericData.setData(0.0, 0.0, 0.0); } return(new MManipData(obj)); }