MManipData componentScaleManip::plugToManipConversion(unsigned index) {
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 index, all
// invocations of the callback should be for that index.
//
MFnScaleManip scaleManip(fScaleManip);
if (index == scaleManip.scaleCenterIndex())
{
// Set the center point for scaling to the centroid of the CV's.
//
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::k3Double );
numericData.setData(centroid.x,centroid.y,centroid.z);
return MManipData(obj);
}
MGlobal::displayError("Invalid index in plugToManipConversion()!");
// For invalid indices, return vector of 0's
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::k3Double );
numericData.setData(0.0,0.0,0.0);
return obj;
}
MManipData componentScaleManip::manipToPlugConversion(unsigned index) {
MObject obj = MObject::kNullObj;
MFnScaleManip scaleManip(fScaleManip);
if (index < (unsigned)numComponents)
{
//
// Now we need to determine the scaled position of the CV specified by
// index.
//
MVector scaleVal;
getConverterManipValue(scaleManip.scaleIndex(), scaleVal);
// Determine the vector from the centroid to the CV
//
MVector positionVec = initialPositions[index] - centroid;
// Scale the vector
//
MVector newPosition(positionVec.x*scaleVal.x,
positionVec.y*scaleVal.y, positionVec.z*scaleVal.z);
// Form the vector from the initial position to the new position.
//
newPosition = newPosition - positionVec;
// Move the control point from the initial control point position along
// the vector. Control point positions are always measured relative to
// the initial position of the control point, which is why a separate
// array of control point positions is required.
//
newPosition += initialControlPoint[index];
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::k3Double );
numericData.setData(newPosition.x,newPosition.y,newPosition.z);
return MManipData(obj);
}
// If we entered the handler with an invalid index, print an error and
// return. The callback should only be called for indices from 0 to
// numComponents-1.
//
MGlobal::displayError("Invalid index in scale changed callback!");
// For invalid indices, return vector of 0's
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::k3Double );
numericData.setData(0.0,0.0,0.0);
return obj;
}
MManipData exampleRotateManip::rotationChangedCallback(unsigned index) {
static MEulerRotation cache;
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.
//
if (index != rotatePlugIndex)
{
MGlobal::displayError("Invalid index in rotation changed callback!");
// For invalid indices, return vector of 0's
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::k3Double );
numericData.setData(0.0,0.0,0.0);
return obj;
}
// Assign function sets to the manipulators
//
MFnStateManip stateManip(fStateManip);
MFnRotateManip rotateManip(fRotateManip);
// Adjust settings on the rotate manip based on the state of the state
// manip.
//
int 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::kObjectSpace);
rotateManip.setSnapMode(true);
rotateManip.setSnapIncrement(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
//
MFnNumericData numericData;
obj = numericData.create( MFnNumericData::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;
if (!getConverterManipValue (rotateManip.rotationIndex(), manipRotation))
{
MGlobal::displayError("Error retrieving manip value");
numericData.setData(0.0,0.0,0.0);
}
else {
numericData.setData(manipRotation.x, manipRotation.y, manipRotation.z);
}
return MManipData(obj);
}
