1.5.6//- // ========================================================================== // 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 ); }
| Autodesk® Maya® 2011 © 1997-2010 Autodesk, Inc. All rights reserved. | Generated with 1.5.6 |