splatDeformer/splatDeformer.cpp
 
 
 
splatDeformer/splatDeformer.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.
// ==========================================================================
//+

//
//  File: splatDeformer.cc
//
//  Description:
//              Example implementation of a threaded deformer. This node
//              deforms one mesh using another.
//

#include <maya/MIOStream.h>

#include <maya/MPxDeformerNode.h> 
#include <maya/MItGeometry.h>
#include <maya/MFnPlugin.h>
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h>
#include <maya/MPoint.h>
#include <maya/MTimer.h>
#include <maya/MFnMesh.h>
#include <maya/MPointArray.h>
#include <maya/MFnTypedAttribute.h>
#include <maya/MFnMeshData.h>
#include <maya/MMeshIntersector.h>

#include <maya/MThreadUtils.h>

// Macros
//
#define MCheckStatus(status,message)    \
        if( MStatus::kSuccess != status ) {     \
                cerr << message << "\n";                \
                return status;                                  \
        }

class splatDeformer : public MPxDeformerNode
{
public:
                                                splatDeformer();
        virtual                         ~splatDeformer();

        static  void*           creator();
        static  MStatus         initialize();

        // deformation function
        //
        virtual MStatus compute(const MPlug& plug, MDataBlock& dataBlock);

public:
        // local node attributes

        static  MTypeId         id;

        static MObject deformingMesh;

private:
};

MTypeId     splatDeformer::id( 0x8104D );
MObject         splatDeformer::deformingMesh;

splatDeformer::splatDeformer() {}
splatDeformer::~splatDeformer() {}

void* splatDeformer::creator()
{
        return new splatDeformer();
}

MStatus splatDeformer::initialize()
{
        // local attribute initialization
        MStatus status;
        MFnTypedAttribute mAttr;
        deformingMesh=mAttr.create( "deformingMesh", "dm", MFnMeshData::kMesh);
        mAttr.setStorable(true);

        //  deformation attributes
        status = addAttribute( deformingMesh );
        MCheckStatus(status, "ERROR in addAttribute\n");

        status = attributeAffects( deformingMesh, outputGeom );
        MCheckStatus(status, "ERROR in attributeAffects\n");

        return MStatus::kSuccess;
}

MStatus splatDeformer::compute(const MPlug& plug, MDataBlock& data)
{
        // do this if we are using an OpenMP implementation that is not the same as Maya's.
        // Even if it is the same, it does no harm to make this call.
        MThreadUtils::syncNumOpenMPThreads();

        MStatus status = MStatus::kUnknownParameter;
        if (plug.attribute() != outputGeom) {
                return status;
        }

        unsigned int index = plug.logicalIndex();
        MObject thisNode = this->thisMObject();

        // get input value
        MPlug inPlug(thisNode,input);
        inPlug.selectAncestorLogicalIndex(index,input);
        MDataHandle hInput = data.inputValue(inPlug, &status);
        MCheckStatus(status, "ERROR getting input mesh\n");
        
        // get the input geometry
        MDataHandle inputData = hInput.child(inputGeom);
        if (inputData.type() != MFnData::kMesh) {
                printf("Incorrect input geometry type\n");
                return MStatus::kFailure;
        }

        // get the input groupId - ignored for now...
        MDataHandle hGroup = inputData.child(groupId);
        unsigned int groupId = hGroup.asLong();

        // get deforming mesh
        MDataHandle deformData = data.inputValue(deformingMesh, &status);
        MCheckStatus(status, "ERROR getting deforming mesh\n");
    if (deformData.type() != MFnData::kMesh) {
                printf("Incorrect deformer geometry type %d\n", deformData.type());
                return MStatus::kFailure;
        }

        MObject dSurf = deformData.asMeshTransformed();
        MFnMesh fnDeformingMesh;
        fnDeformingMesh.setObject( dSurf ) ;

        MDataHandle outputData = data.outputValue(plug);
        outputData.copy(inputData);
        if (outputData.type() != MFnData::kMesh) {
                printf("Incorrect output mesh type\n");
                return MStatus::kFailure;
        }
        
        MItGeometry iter(outputData, groupId, false);

        // create fast intersector structure
        MMeshIntersector intersector;
        intersector.create(dSurf);

        // get all points at once. Faster to query, and also better for
        // threading than using iterator
        MPointArray verts;
        iter.allPositions(verts);
        int nPoints = verts.length();

        // use bool variable as lightweight object for failure check in loop below
        bool failed = false;

        MTimer timer; timer.beginTimer();

#ifdef _OPENMP
#pragma omp parallel for
#endif
        for(int i=0; i<nPoints; i++) {

                // Cannot break out of an OpenMP loop, so if one of the
                // intersections failed, skip the rest
                if(failed) continue;

                // mesh point object must be in loop-local scope to avoid race conditions
                MPointOnMesh meshPoint;

                // Do intersection. Need to use per-thread status value as
                // MStatus has internal state and may trigger race conditions
                // if set from multiple threads. Probably benign in this case,
                // but worth being careful.
                MStatus localStatus = intersector.getClosestPoint(verts[i], meshPoint);
                if(localStatus != MStatus::kSuccess) {
                        // NOTE - we cannot break out of an OpenMP region, so set
                        // bad status and skip remaining iterations
                        failed = true;
                        continue;
                }

                // default OpenMP scheduling breaks traversal into large
                // chunks, so low risk of false sharing here in array write.
                verts[i] = meshPoint.getPoint();
        }

        timer.endTimer(); printf("Runtime for threaded loop %f\n", timer.elapsedTime());

        // write values back onto output using fast set method on iterator
        iter.setAllPositions(verts);

        if(failed) {
                printf("Closest point failed\n");
                return MStatus::kFailure;
        }

        return status;
}

// standard initialization procedures
//
MStatus initializePlugin( MObject obj )
{
        MStatus result;
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "1.0", "Any");
        result = plugin.registerNode( "splatDeformer", splatDeformer::id, splatDeformer::creator, 
                                                                  splatDeformer::initialize, MPxNode::kDeformerNode );

        return result;
}

MStatus uninitializePlugin( MObject obj)
{
        MStatus result;
        MFnPlugin plugin( obj );
        result = plugin.deregisterNode( splatDeformer::id );
        return result;
}