//
// Matrix constructor. Initialize any
// class variables.
//
rockingTransformMatrix::rockingTransformMatrix()
{
    rockXValue = 0.0;
}
//
// Creator for matrix
//
void *rockingTransformMatrix::creator()
{
    return new rockingTransformMatrix();
}
//
// Utility method for getting the rock
// motion in the X axis
//
double rockingTransformMatrix::getRockInX() const
{
    return rockXValue;
}
//
// Utility method for setting the rcok 
// motion in the X axis
//
void rockingTransformMatrix::setRockInX( double rock )
{
    rockXValue = rock;
}

//
// This method will be used to return information to
// Maya. Use the attributes which are outside of
// the regular transform attributes to build a new
// matrix. This new matrix will be passed back to
// Maya.
//
MMatrix rockingTransformMatrix::asMatrix() const
{
    // Get the current transform matrix
    MMatrix m = ParentClass::asMatrix();
    // Initialize the new matrix we will calculate
    MTransformationMatrix tm( m );
    // Find the current rotation as a quaternion
    MQuaternion quat = rotation();
    // Convert the rocking value in degrees to radians
    DegreeRadianConverter conv;
    double newTheta = conv.degreesToRadians( getRockInX() );
    quat.setToXAxis( newTheta );
    // Apply the rocking rotation to the existing rotation
    tm.addRotationQuaternion( quat.x, quat.y, quat.z, quat.w, MSpace::kTransform );
    // Let Maya know what the matrix should be
    return tm.asMatrix();
}

//
//    Node initialize method. We configure node
//    attributes here. Static method so
//    the *this pointer is not available.
//
MStatus rockingTransformNode::initialize()
{
    MFnNumericAttribute numFn;
    aRockInX = numFn.create("RockInX", "rockx",
         MFnNumericData::kDouble, 0.0);
    numFn.setKeyable(true);
    numFn.setAffectsWorldSpace(true);
    addAttribute(aRockInX);
    // This is required so that the validateAndSet method 
    // is called
    mustCallValidateAndSet(aRockInX);
    return MS::kSuccess;
}

//
// Constructor of the transform node
//
rockingTransformNode::rockingTransformNode()
: ParentClass()
{
    rockXValue = 0.0;
}
//
// Constructor of the transform node
//
rockingTransformNode::rockingTransformNode(MPxTransformationMatrix *tm)
: ParentClass(tm)
{
    rockXValue = 0.0;
}
//
// Post constructor method. Has access to *this. Node setup
// operations that do not go into the initialize() method should go
// here.
//
void rockingTransformNode::postConstructor()
{
    // Make sure the parent takes care of anything it needs.
    //
    ParentClass::postConstructor();
    // The baseTransformationMatrix pointer should be setup properly 
    // at this point, but just in case, set the value if it is missing.
    //
    if (NULL == baseTransformationMatrix) {
        MGlobal::displayWarning("NULL baseTransformationMatrix found!");
        baseTransformationMatrix = new MPxTransformationMatrix();
    }
}
//
// Destructor of the rocking transform
//
rockingTransformNode::~rockingTransformNode()
{
}
//
// Method that returns the new transformation matrix
//
MPxTransformationMatrix *rockingTransformNode::createTransformationMatrix()
{
    return new rockingTransformMatrix();
}
//
// Method that returns a new transform node
//
void *rockingTransformNode::creator()
{
    return new rockingTransformNode();
}

MStatus rockingTransformNode::validateAndSetValue(
const MPlug& plug,
    const MDataHandle& handle,
    const MDGContext& context)
{
    MStatus status = MS::kSuccess;
    // Make sure that there is something interesting to process.
    //
    if (plug.isNull())
        return MS::kFailure;
    MDataBlock block = forceCache(*(MDGContext *)&context);
    MDataHandle blockHandle = block.outputValue(plug, &status);
    ReturnOnError(status);
    
    if ( plug == aRockInX )
    {
        // Update our new rock in x value
        double rockInX = handle.asDouble();
        blockHandle.set(rockInX);
        rockXValue = rockInX;
        
        // Update the custom transformation matrix to the
        // right rock value. 
        rockingTransformMatrix *ltm = getRockingTransformMatrix();
        if (ltm)
            ltm->setRockInX(rockXValue);
        else 
            MGlobal::displayError("Failed to get rock transform matrix");
            
        blockHandle.setClean();
        
        // Mark the matrix as dirty so that DG information
        // will update.
        dirtyMatrix();        
    }
    
    // Allow processing for other attributes
    return ParentClass::validateAndSetValue(plug, handle, context);
}