hairCollisionSolver/hairCollisionSolver.cpp

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 );
}
Please send us your comment about this page