hairCollisionSolver/hairCollisionSolver.cpp

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

#include <maya/MIOStream.h>
#include <maya/MStatus.h>
#include <maya/MDagPath.h>
#include <maya/MFloatPointArray.h>
#include <maya/MObject.h>
#include <maya/MPlugArray.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MFnDagNode.h>
#include <maya/MFnMesh.h>
#include <maya/MHairSystem.h>
#include <maya/MFnPlugin.h>

#include <math.h> 

#define kPluginName     "hairCollisionSolver"

//
//
// OVERVIEW:
// This plug-in implements a custom collision solver for Maya's dynamic
// hair system. This allows users to override the following aspects of
// Maya's dynamic hair systems:
//
//      o Override the Maya dynamic hair system's object-to-hair
//        collision algorithm with a user-defined algorithm.
//      o Optionally perform global filtering on hair, such as freeze,
//        smoothing, etc.
//
// It should be noted that Maya's dynamic hair system involves four
// arears of collision detection, and this plug-in is specific to the
// Hair-to-Object aspect only. The four areas collision which the Maya
// dynamic hair system involves are:
//
//      1) Hair to object collision.
//      2) Hair to implicit object collision.
//      3) Hair to ground plane collision.
//      4) Self collision between hairs.
//
// This plug-in illustrates the first case, overriding Maya's internal
// Hair-to-Object collision solver. There is currently no API for over-
// riding the other three collision solvers.
//
//
// RATIONALE:
// There are several reasons why are user may wish to override Maya's
// internal hair to object collision algorithm. These are:
//
//      1) The internal algorithm may not be accurate enough. After all,
//         it is a simulation of real-life physics and there are tradeoffs
//         taken to provide reasonable performance. Note that there are
//         means of increasing the accuracy without writing a custom
//         implementation, such as decreasing the dynamics time step, or
//         increasing the hair width.
//      2) The built-in algorithm might be too accurate. If you only want
//         simplified collisions, such as against a bounding box repre-
//         sentation instead of the internal algorithm's exhasutive test-
//         ing against each surface of the object, you could write a
//         lighter-weight implementation.
//      3) You might have a desire to process the hairs, such as smooth
//         them out.
//
//
// STRATEGY:
// The basic idea is to implement a custom callback which is registered
// via MHairSystem::registerCollisionSolverCollide(). Your callback will
// then be invoked in place of Maya's internal collision solver. By simply
// registering a collision solver, you can completely implement a custom
// hair-to-object solution.
//
// However, since the collision solver is called once per hair times the
// number of solver iterations, it is wise to pre-process the data if
// possible to speed up the collision tests. For this reason, you can
// assign a pre-frame callback. One approach is to create a pre-processed
// representation of your object pre-frame (e.g. an octree representation)
// and then access this representation during the collision testing.
//
// For the purposes of our simple demo plug-in, our private data will
// consist of a COLLISION_INFO which contains an array of COLLISION_OBJ
// structures, each one holding the bounding box of the object in world
// space.
//
// One issue with pre-processing the data involves managing the private
// data. A collision object could be deleted or turned off during a
// simulation. One way to cleanly manage such data is to store your
// private data on a typed attribute which is added to the node. You
// would build your private data once at the start of simulation in your
// pre-frame callback (keep track of the current time, and if the curTime
// passed in is less than what you store locally, assume the playback
// has restarted from the beginning -- or the user is being silly and
// trying to play the simulation backwards :-) Since it is relatively
// expensive to look up a dynamic attribute value, and the collide()
// callback can get triggered 1000's of times per frame, for efficiency
// you can pass back your private data as a pointer from your pre-frame
// routine, and this pointer is then passed directly into your collide()
// callback.
// 
//
typedef struct {
    int             numVerts;   // Number of vertices in object.
    double          minx;       // Bounding box minimal extrema.
    double          miny;       // Bounding box minimal extrema.
    double          minz;       // Bounding box minimal extrema.
    double          maxx;       // Bounding box maximal extrema.
    double          maxy;       // Bounding box maximal extrema.
    double          maxz;       // Bounding box maximal extrema.
} COLLISION_OBJ ;

typedef struct {
    int             numObjs;    // Number of collision objects.
    COLLISION_OBJ   *objs;      // Array of per-object info.
} COLLISION_INFO ;

//
// Synopsis:
//      bool    preFrame( hairSystem, curTime, privateData )
//
// Description:
//      This callback is invoked once at the start of each frame, allowing
//  the user to perform any pre-processing as they see fit, such as build-
//  ing or updating private collision-detection structures.
//
//      Note: it is possible for collision objects to change between
//  frames during a simulation (for example, the user could delete a col-
//  lision object), so if you choose to store your pre-processed data, it
//  is critical to track any edits or deletions to the collision object
//  to keep your pre-processed data valid.
//
//      There are lots of hints for writing an effective pre-frame call-
//  back in the STRATEGY section listed earlier in this file.
//
// Parameters:
//      MObject hairSystem  : (in)  The hair system shape node.
//      double  curTime     : (in)  Current time in seconds.
//      void    **privateData:(out) Allows the user to return a private
//                                  data pointer to be passed into their
//                                  collision solver. If you store your
//                                  pre-processed data in data structure
//                                  which is difficult to access, such as
//                                  on a typed attribute, this provides
//                                  an easy way to provide the pointer.
//
// Returns:
//      bool    true        : Successfully performed any needed initial-
//                            isation for the hair simulation this frame.
//      bool    false       : An error was detected.
//


bool        preFrame(
                const MObject       hairSystem,
                const double        curTime,
                void                **privateData )
{
    MStatus status;

    // If you need want to perform any preprocessing on your collision
    // objects pre-frame, do it here. One option for storing the pre-
    // processed data is on a typed attribute on the hairSystem node.
    // That data could be fetched and updated here.
    //
    // In our example, we'll just compute a bounding box here and NOT use
    // attribute storage. That is an exercise for the reader.
    //
    MFnDependencyNode fnHairSystem( hairSystem, &status );
    CHECK_MSTATUS_AND_RETURN( status, false );
    fprintf( stderr,
            "preFrame: calling hairSystem node=`%s', time=%g\n",
            fnHairSystem.name().asChar(), curTime );
    MObjectArray    cols;
    MIntArray       logIdxs;
    CHECK_MSTATUS_AND_RETURN( MHairSystem::getCollisionObject( hairSystem,
            cols, logIdxs ), false );
    int nobj = cols.length();

    // Allocate private data.
    // This allows us to pre-process data on a pre-frame basis to avoid
    // calculating it per hair inside the collide() call. As noted earlier
    // we could allocate this in preFrame() and hang it off the hairSystem
    // node via a dynamic attribute.
    // Instead we'll allocate it here.
    //
    COLLISION_INFO *collisionInfo = (COLLISION_INFO *) malloc(
            sizeof( COLLISION_INFO ) );
    collisionInfo->objs = (COLLISION_OBJ *) malloc(
            nobj * sizeof( COLLISION_OBJ ) );
    collisionInfo->numObjs = nobj;

    // Create the private data that we'll make available to the collide
    // method. The data should actually be stored in a way that it can
    // be cleaned up (such as storing the pointer on the hairSystem node
    // using a dynamic attribute). As it stands right now, there is a
    // memory leak with this plug-in because the memory we're allocating
    // for the private data is never cleaned up.
    //
    // Note that when using the dynamic attribute approach, it is still
    // wise to set *privateData because this avoids the need to look up
    // the plug inside the collide() routine which is a high-traffic
    // method.
    //
    *privateData = (void *) collisionInfo;

    // Loop through the collision objects and pre-process, storing the
    // results in the collisionInfo structure.
    //
    int    obj;
    for ( obj = 0; obj < nobj; ++obj ) {
        // Get the ith collision geometry we are connected to.
        //
        MObject colObj = cols[obj];

        // Get the DAG path for the collision object so we can transform
        // the vertices to world space.
        //
        MFnDagNode fnDagNode( colObj, &status );
        CHECK_MSTATUS_AND_RETURN( status, false );
        MDagPath path;
        status = fnDagNode.getPath( path );
        CHECK_MSTATUS_AND_RETURN( status, false );
        MFnMesh fnMesh( path, &status );
        if ( MS::kSuccess != status ) {
            fprintf( stderr,
                    "%s:%d: collide was not passed a valid mesh shape\n",
                    __FILE__, __LINE__ );
            return( false );
        }

        // Get the vertices of the object transformed to world space.
        //
        MFloatPointArray    verts;
        status = fnMesh.getPoints( verts, MSpace::kWorld );
        CHECK_MSTATUS_AND_RETURN( status, false );

        // Compute the bounding box for the collision object.
        // As this is a quick and dirty demo, we'll just support collisions
        // between hair and the bbox.
        //
        double minx, miny, minz, maxx, maxy, maxz, x, y, z;
        minx = maxx = verts[0].x;
        miny = maxy = verts[0].y;
        minz = maxz = verts[0].z;
        int nv = verts.length();
        int i;
        for ( i = 1; i < nv; ++i ) {
            x = verts[i].x;
            y = verts[i].y;
            z = verts[i].z;

            if ( x < minx ) {
                minx = x;
            }
            if ( y < miny ) {
                miny = y;
            }
            if ( z < minz ) {
                minz = z;
            }

            if ( x > maxx ) {
                maxx = x;
            }
            if ( y > maxy ) {
                maxy = y;
            }
            if ( z > maxz ) {
                maxz = z;
            }
        }

        // Store this precomputed informantion into our private data
        // structure.
        //
        collisionInfo->objs[obj].numVerts = nv;
        collisionInfo->objs[obj].minx = minx;
        collisionInfo->objs[obj].miny = miny;
        collisionInfo->objs[obj].minz = minz;
        collisionInfo->objs[obj].maxx = maxx;
        collisionInfo->objs[obj].maxy = maxy;
        collisionInfo->objs[obj].maxz = maxz;
        fprintf( stderr, "Inside preFrameInit, bbox=%g %g %g %g %g %g\n",
                minx,miny,minz,maxx,maxy,maxz);
    }

    return( true );
}

//
// Synopsis:
//      bool    belowCollisionPlane( co, pnt )
//
// Description:
//      Test if `pnt' is directly below the collision plane of `co'.
//
// Parameters:
//      COLLISION_OBJ   *co : (in)  The collision object to test against.
//      MVector         &pnt: (in)  Point to test.
//
// Returns:
//      bool    true        : The `pnt' is directly below the collision
//                            plane specified by `co'.
//      bool    false       : The `pnt' is not directly below the collis-
//                            ion plane specified by `co'.
//


bool    belowCollisionPlane( const COLLISION_OBJ *co, const MVector &pnt )
{
    return(    pnt.x > co->minx && pnt.x < co->maxx
                                && pnt.y < co->maxy
            && pnt.z > co->minz && pnt.z < co->maxz );
}

//
// Synopsis:
//      MStatus collide( hairSystem, follicleIndex, hairPositions,
//                      hairPositionsLast, hairWidths, startIndex,
//                      endIndex, curTime, friction, privateData )
//
// Description:
//      This callback is invoked by Maya to test if a collision exists be-
//  tween the follicle (defined by `hairPositions', `hairPositionsLast'
//  and `hairWidths') and the collision objects associated with the
//  hairSystem. If a collision is detected, this routine should adjust
//  `hairPositions' to compensate. The `hairPositionsLast' can also be
//  modified to adjust the velocity, but this should only be a dampening
//  effect as the hair solver expects collisions to be dampened,
//
//      This method is invoked often (actually its once per hair times the
//  hairSystem shape's iterations factor). Thus with 10,000 follicles it
//  would be called 80,000 times per frame (Note: as of Maya 7.0, the
//  iterations factor is multipled by 2, so at its default value of 4, you
//  get 8x calls. However, if you set iterations=0, it clamps to 1x calls).
//
// Parameters:
//      MObject hairSystem  : (in)  The hair system shape node.
//      int     follicleIndex:(in)  Which follicle we are processing.
//                                  You can get the follicle node if you
//                                  wish via MHairSystem::getFollicle().
//      MVectorArray &hairPositions:
//                            (mod) Array of locations in world space
//                                  where the hair system is trying to
//                                  move the follicle. The first entry
//                                  corresponds to the root of the hair
//                                  and the last entry to the tip. If a
//                                  collision is detected, these values
//                                  should be updated appropriately.
//                                  Note that hairPositions can change
//                                  from iteration to iteration on the
//                                  same hair and same frame. You can set
//                                  a position, and then find the hair has
//                                  moved a bit the next iteration. There
//                                  are two reasons for this phenomenom:
//                                    1) Other collisions could occur,
//                                       including self collision.
//                                    2) Stiffness is actually applied PER
//                                       ITERATION.
//      MVectorArray &hairPositionsLast:
//                            (mod) Array of the position at the previous
//                                  time for each entry in `hairPositions'.
//      MDoubleArray &hairWidths:
//                            (in)  Array of widths, representing the
//                                  width of the follcle at each entry in
//                                  `hairPositions'.
//      int     startIndex  : (in)  First index in `hairPositions' we
//                                  can move. This will be 0 unless the
//                                  root is locked in which case it will
//                                  be 1.
//      int     endIndex    : (in)  Last index in `hairPositions' we can
//                                  move. Will be the full array (N-1)
//                                  unless the tip is locked.
//      double  curTime     : (in)  Start of current time interval.
//      double  friction    : (in)  Frictional coefficient.
//      void    *privateData: (in)  If a privateData record was returned
//                                  from preFrame() it will be passed in
//                                  here. This is an optimisation to save
//                                  expensive lookups of your private data
//                                  if stored on the node.
//
// Returns:
//      bool    true        : Successfully performed collision testing and
//                            adjustment of the hair array data.
//      bool    false       : An error occurred.
//


#define EPSILON 0.0001

bool    collide(
                const MObject       hairSystem,
                const int           follicleIndex,
                MVectorArray        &hairPositions,
                MVectorArray        &hairPositionsLast,
                const MDoubleArray  &hairWidths,
                const int           startIndex,
                const int           endIndex,
                const double        curTime,
                const double        friction,
                const void          *privateData )
{
    // Get the private data for the collision objects which was returned
    // from preFrame().
    //
    COLLISION_INFO *ci = (COLLISION_INFO *) privateData;
    if ( !ci ) {
        fprintf( stderr,"%s:%d: collide() privateData pointer is NULL\n",
                __FILE__, __LINE__ );
        return( false );
    }

    // If object has no vertices, or hair has no segments, then there is
    // nothing to collide. In our example, we'll return here, but if you
    // want to implement your own hair processing such as smoothing or
    // freeze on the hair, you could proceed and let the processing happen
    // after the object loop so that the data gets processed even if no
    // collisions occur.
    //
    if ( ci->numObjs <= 0 || hairPositions.length() <= 0 ) {
        return( true );
    }

    int     obj;
    for ( obj = 0; obj < ci->numObjs; ++obj ) {
        COLLISION_OBJ *co = &ci->objs[obj];

        // For our plug-in example, we just collide the segments of the
        // hair against the top of the bounding box for the geometry.
        // In an implementation where you only care about hair falling
        // downwards onto flat objects, this might be OK. However, in the
        // most deluxe of implementation, you should do the following:
        //
        //      o  Determine the motion of each face of your collision
        //         object during the time range.
        //      o  Step through the follicle, and consider each segment
        //         to be a moving cylinder where the start and end radii
        //         can differ. The radii come from `hairWidths' and the
        //         motion comes from the difference between `hairPositions'
        //         and `hairPositionsLast'.
        //      o  Intersect each moving element (e.g. moving triangle
        //         if you have a mesh obect) with each hair segment
        //         e.g. moving cylinder). This intersection may occur
        //         at a point within the frame. (Remember that the
        //         hairPositions[] array holds the DESIRED location where
        //         the hair system wants the hair to go.
        //      o  There can be multiple collisions along a hair segment.
        //         Use the first location found and the maximal velocity.
        //
        // If a collision is detected, the `hairPositions' array should be
        // updated. `hairPositionsLast' may also be updated to provide a
        // dampening effect only.
        //

        // Loop through the follicle, starting at the root and advancing
        // toward the tip.
        //
        int     numSegments = hairPositions.length() - 1;
        int     seg;
        for ( seg = 0; seg < numSegments; ++seg ) {
            // Get the desired position of the segment (i.e. where the
            // solver is trying to put the hair for the current frame)
            // and the velocity required to get to that desired position.
            //
            // Thus,
            //      P = hairPositions       // Desired pos'n at cur frame.
            //      L = hairPositionsLast   // Position at prev frame.
            //      V = P - L               // Desired velocity of hair.
            //
            MVector pStart = hairPositions[seg];
            MVector pEnd = hairPositions[seg + 1];

            MVector vStart = pStart - hairPositionsLast[seg];
            MVector vEnd = pEnd - hairPositionsLast[seg + 1];

            // The proper way to time sample is to intersect the moving
            // segment of width `hairWidths[seg] to hairWidths[seg + 1]'
            // with the moving collision object. For the purposes of our
            // demo plug-in, we will simply assume the collision object is
            // static, the hair segment has zero width, and instead of
            // intersecting continuously in time, we will sample discrete
            // steps along the segment.
            //
            #define STEPS 4
            int     step;
            for ( step = 0; step < STEPS; ++step ) {
                // Compute the point for this step and its corresponding
                // velocity. This is a "time swept" point:
                //  p1 = desired position at current time
                //  p0 = position at previous time to achieve desired pos
                //
                MVector pCur, pPrev, v;
                double fracAlongSeg = step / ( (double) STEPS );
                v = vStart * ( 1.0 - fracAlongSeg ) + vEnd * fracAlongSeg;
                MVector p1 = pStart * ( 1.0 - fracAlongSeg )
                        + pEnd * fracAlongSeg;
                MVector p0 = p1 - v;

                // See if BOTH endpoints are outside of the bounding box
                // on the same side. If so, then the segment cannot
                // intersect the bounding box. Note that we assume the
                // bounding box is static.
                //
                if (       (p0.x < co->minx && p1.x < co->minx)
                        || (p0.y < co->miny && p1.y < co->miny)
                        || (p0.z < co->minz && p1.z < co->minz)
                        || (p0.x > co->maxx && p1.x > co->maxx)
                        || (p0.y > co->maxy && p1.y > co->maxy)
                        || (p0.z > co->maxz && p1.z > co->maxz) ) {
                    continue;
                }

                // For the purposes of this example plug-in, we'll assume
                // the hair always moves downwards (due to gravity and
                // thus in the negative Y direction). As such, we only
                // need to test for collisions with the TOP of the
                // bounding box. Expanding the example to all 6 sides is
                // left as an exercise for the reader.
                //
                // Remember that p1 is the point at current time, and
                // p0 is the point at the previous time. Since we assume
                // the bounding box to be static, this simplifies things.
                //
                MVector where(-100000,-100000,-100000); // Loc'n of collision
                double  fracTime;   // Time at which collision happens 0..1

                if ( fabs( v.y ) < EPSILON      // velocity is zero
                        && fabs( p1.y - co->maxy ) < EPSILON ) {    // right on the bbox
                    // Velocity is zero and the desired location (p1) is
                    // right on top of the bounding box.
                    //
                    where = p1;
                    fracTime = 1.0;     // Collides right at end;
                } else {
                    fracTime = ( co->maxy -  p0.y ) / v.y;
                    if ( fracTime >= 0.0 && fracTime <= 1.0 ) {
                        // Compute the collision of the swept point with the
                        // plane defined by the top of the bounding box.
                        //
                        where = p0 + v * fracTime;
                    }
                }

                // If `seg' lies between startIndex and endIndex
                // we can move it. If its <= startIndex, the root is
                // locked and if >= endIndex the tip is locked.
                //
                if ( seg >= startIndex && seg <= endIndex ) {
                    // Since we are just colliding with the top of the
                    // bounding box, the normal where we hit is (0,1,0).
                    // For the object velocity, we SHOULD measure the
                    // relative motion of the object during the time
                    // interval, but for our example, we'll assume its
                    // not moving (0,0,0).
                    //
                    bool segCollides = false;
                    MVector normal(0.0,1.0,0.0);    // normal is always up
                    MVector objectVel(0.0,0.0,0.0); // assume bbox is static

                    // If we get the this point, then the intersection
                    // point `where' is on the plane of the bounding box
                    // top. See if it lies within the actual bounds of the
                    // boxtop, and if so compute the position and velocity
                    // information and apply to the hair segment.
                    //
                    if ( where.x >= co->minx && where.x <= co->maxx
                            && where.z >= co->minz && where.z <= co->maxz
                            && fracTime >= 0.0 && fracTime <= 0.0 ) {
                        // We have a collision at `where' with the plane.
                        // Compute the new velocity for the hair at the
                        // point of collision.
                        //
                        MVector objVelAlongNormal = (objectVel * normal)
                                * normal;
                        MVector objVelAlongTangent = objectVel
                                - objVelAlongNormal;
                        MVector pntVelAlongTangent = v - ( v * normal )
                                * normal;
                        MVector reflectedPntVelAlongTangent
                                = pntVelAlongTangent * ( 1.0 - friction )
                                + objVelAlongTangent * friction;
                        MVector newVel = objVelAlongNormal
                                + reflectedPntVelAlongTangent;

                        // Update the hair position. It actually looks
                        // more stable from a simulation standpoint to
                        // just move the closest segment endpoint, but
                        // you are free to experiment. What we'll do in
                        // our example is move the closest segment end-
                        // point by the amount the collided point (where)
                        // has to move to have velocity `newVel' yet still
                        // pass through `where' at time `fracTime'.
                        //
                        if ( fracAlongSeg > 0.5 ) {
                            MVector deltaPos = -newVel * fracTime;
                            hairPositionsLast[seg + 1] += deltaPos;
                            hairPositions[seg + 1] = hairPositionsLast[seg]
                                    + newVel;
                        } else {
                            MVector deltaPos = newVel * fracTime;
                            hairPositionsLast[seg] += deltaPos;
                            hairPositions[seg] = hairPositionsLast[seg]
                                    + newVel;
                        }
                        segCollides = true;
                    }

                    // Check for segment endpoints that may still be
                    // inside. Note that segments which started out being
                    // totally inside will never collide using the
                    // algorithm we use above, so we'll simply clamp them
                    // here. One might expect an inside-the-bounding-box
                    // test instead. However, this does not work if the
                    // collision object is a very thin object.
                    //
                    bool inside = false;
                    if ( belowCollisionPlane( co, hairPositions[seg] ) ) {
                        hairPositions[seg].y = co->maxy + EPSILON;
                        hairPositionsLast[seg] = hairPositions[seg] - objectVel;
                        inside = true;
                    }
                    if ( belowCollisionPlane( co, hairPositions[seg+1] ) ) {
                        hairPositions[seg+1].y = co->maxy + EPSILON;
                        hairPositionsLast[seg+1] = hairPositions[seg+1] - objectVel;
                        inside = true;
                    }

                    // If we collided, go onto the next segment.
                    //
                    if ( segCollides || inside ) {
                        goto nextSeg;
                    }
                }
            }
nextSeg:;
        }
    }

    // You could perform any global filtering that you want on the hair
    // right here. For example: smoothing. This code is independent of
    // whether or not a collision occurred, and note that collide() is
    // called even with zero collision objects, so you will be guaranteed
    // of reaching here once per hair per iteration.
    //

    return( true );
}

//
// Synopsis:
//      MStatus initializePlugin( MObject obj )
//
// Description:
//      Invoked upon plug-in load to register the plug-in and initialise.
//
// Parameters:
//      MObject obj         : (in)  Plug-in object being loaded.
//
// Returns:
//      MStatus::kSuccess   : Successfully performed any needed initial-
//                            isation for the plug-in.
//      MStatus statusCode  : Error was detected.
//


MStatus initializePlugin( MObject obj )
{
    MFnPlugin   plugin( obj, "Autodesk", "8.0", "Any" );

    CHECK_MSTATUS( MHairSystem::registerCollisionSolverCollide( collide ) );
    CHECK_MSTATUS( MHairSystem::registerCollisionSolverPreFrame( preFrame ) );

    return( MS::kSuccess );
}

//
// Synopsis:
//      MStatus uninitializePlugin( MObject obj )
//
// Description:
//      Invoked upon plug-in unload to deregister the plug-in and clean up.
//
// Parameters:
//      MObject obj         : (in)  Plug-in object being unloaded.
//
// Returns:
//      MStatus::kSuccess   : Successfully performed any needed cleanup.
//      MStatus statusCode  : Error was detected.
//


MStatus uninitializePlugin( MObject obj )
{
    MFnPlugin   plugin( obj );

    CHECK_MSTATUS( MHairSystem::unregisterCollisionSolverCollide() );
    CHECK_MSTATUS( MHairSystem::unregisterCollisionSolverPreFrame() );

    return( MS::kSuccess );
}