//-
// ==========================================================================
// 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 );
}