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

//
// particleSystemInfoCmd
//
// Demonstrates the use of the new MFnParticleSystem class for retrieving
// particle information.  The number of particle positions followed by
// the positions are printed to the script editor.
//
//  Syntax:
//      particleSystemInfo $particleNodeName;
//
//  Example:
//  particleSystemInfo particleShape2;
//

#include <assert.h>

#include <maya/MIOStream.h>
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MPoint.h>
#include <maya/MVector.h>
#include <maya/MPointArray.h>
#include <maya/MVectorArray.h>
#include <maya/MFloatMatrix.h>
#include <maya/MArgList.h>
#include <maya/MPlug.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MDagPath.h>
#include <maya/MItDag.h>
#include <maya/MSelectionList.h>
#include <maya/MPlug.h>
#include <maya/MPlugArray.h>
#include <maya/MPxCommand.h>
#include <maya/MFnDagNode.h>
#include <maya/MFnParticleSystem.h>
#include <maya/MFnPlugin.h>
#include <maya/MObjectArray.h>

#define mCommandName "particleSystemInfo"   // Command name

#define CHECKRESULT(stat,msg)     \
        if ( MS::kSuccess != stat ) { \
                cerr << msg << endl;      \
        }

class particleSystemInfoCmd : public MPxCommand
{
public:
                 particleSystemInfoCmd();
    virtual     ~particleSystemInfoCmd();

    virtual MStatus doIt ( const MArgList& args );

    static void* creator();

private:

    static MStatus nodeFromName(MString name, MObject & obj);

    MStatus parseArgs ( const MArgList& args );

    MObject particleNode;
};

particleSystemInfoCmd::particleSystemInfoCmd()
{
}

particleSystemInfoCmd::~particleSystemInfoCmd() 
{
}


//
//

MStatus particleSystemInfoCmd::nodeFromName(MString name, MObject & obj)
{
    MSelectionList tempList;
    tempList.add( name );
    if ( tempList.length() > 0 ) 
    {
        tempList.getDependNode( 0, obj );
        return MS::kSuccess;
    }
    return MS::kFailure;
}




MStatus particleSystemInfoCmd::parseArgs( const MArgList& args )
{
    // Parse the arguments.
    MStatus stat = MS::kSuccess;

    if( args.length() > 1 )
    {
        MGlobal::displayError( "Too many arguments." );
        return MS::kFailure;
    }

    if( args.length() == 1 )
    {
            MString particleName = args.asString( 0, &stat );
        CHECKRESULT(stat, "Failed to parse particle node name argument." );

        nodeFromName( particleName, particleNode );
        
        if( !particleNode.isNull() && !particleNode.hasFn( MFn::kParticle ) )
        {
                MGlobal::displayError( "The named node is not a particle system." );
            return MS::kFailure;
        }
    } 
    return MS::kSuccess;
}


//
// Main routine
MStatus particleSystemInfoCmd::doIt( const MArgList& args )
{
    MStatus stat = parseArgs( args );
    if( stat != MS::kSuccess ) return stat;

    if( particleNode.isNull() ) {
            MObject parent;
        MFnParticleSystem dummy;
        particleNode = dummy.create(&stat);
        CHECKRESULT(stat,"MFnParticleSystem::create(status) failed!");

        MFnParticleSystem ps( particleNode, &stat );
        CHECKRESULT(stat,"MFnParticleSystem::MFnParticleSystem(MObject,status) failed!");

        MPointArray posArray;
        posArray.append(MPoint(-5,  5, 0));
        posArray.append(MPoint(-5, 10, 0));

        MVectorArray velArray;
        velArray.append(MPoint(1, 1, 0));
        velArray.append(MPoint(1, 1, 0));
        stat = ps.emit(posArray, velArray);
        CHECKRESULT(stat,"MFnParticleSystem::emit(posArray,velArray) failed!");

        stat = ps.emit(MPoint(5,  5, 0));
        CHECKRESULT(stat,"MFnParticleSystem::emit(pos) failed!");
        stat = ps.emit(MPoint(5, 10, 0));
        CHECKRESULT(stat,"MFnParticleSystem::emit(pos) failed!");

        stat = ps.saveInitialState();
        CHECKRESULT(stat,"MFnParticleSystem::saveInitialState() failed!");

        MVectorArray accArray;
        accArray.setLength(4);
        for( unsigned int i=0; i<accArray.length(); i++ )
        {
                MVector& acc = accArray[i];
            acc.x = acc.y = acc.z = 3.0;
        }
        MString accName("acceleration");
        ps.setPerParticleAttribute( accName, accArray, &stat );
        CHECKRESULT(stat,"MFnParticleSystem::setPerParticleAttribute(vectorArray) failed!");
    } 

    MFnParticleSystem ps( particleNode, &stat );
    CHECKRESULT(stat,"MFnParticleSystem::MFnParticleSystem(MObject,status) failed!");

    if( ! ps.isValid() )
    {
        MGlobal::displayError( "The function set is invalid!" );
        return MS::kFailure;
    }

    const MString name = ps.particleName();
    const MFnParticleSystem::RenderType psType = ps.renderType();
    const unsigned int count = ps.count();

    const char* typeString = NULL;
    switch( psType )
    {
    case MFnParticleSystem::kCloud:
        typeString = "Cloud";
        break;
    case MFnParticleSystem::kTube:
        typeString = "Tube system";
        break;
    case MFnParticleSystem::kBlobby:
        typeString = "Blobby";
        break;
    case MFnParticleSystem::kMultiPoint:
        typeString = "MultiPoint";
        break;
    case MFnParticleSystem::kMultiStreak:
        typeString = "MultiStreak";
        break;
    case MFnParticleSystem::kNumeric:
        typeString = "Numeric";
        break;
    case MFnParticleSystem::kPoints:
        typeString = "Points";
        break;
    case MFnParticleSystem::kSpheres:
        typeString = "Spheres";
        break;
    case MFnParticleSystem::kSprites:
        typeString = "Sprites";
        break;
    case MFnParticleSystem::kStreak:
        typeString = "Streak";
        break;
    default:
        typeString = "Particle system";
        assert( false );
        break;
    }

    char buffer[256];

    sprintf( buffer, "%s \"%s\" has %u primitives.", typeString, name.asChar(), count );
    MGlobal::displayInfo( buffer );

    unsigned i;

    MIntArray ids;
    ps.particleIds( ids );

    sprintf( buffer, "count : %u ", count );
    MGlobal::displayInfo( buffer );
    sprintf( buffer, "%u ids.", ids.length() );
    MGlobal::displayInfo( buffer );

    assert( ids.length() == count );
    for( i=0; i<ids.length(); i++ )
    {
        sprintf( buffer, "id %d  ", ids[i] );
        MGlobal::displayInfo( buffer );
    }

    MVectorArray positions;
    ps.position( positions );
    assert( positions.length() == count );
    for( i=0; i<positions.length(); i++ )
    {
        MVector& p = positions[i];
        sprintf( buffer, "pos %f %f %f  ", p[0], p[1], p[2] );
        MGlobal::displayInfo( buffer );
    }

    MVectorArray vels;
    ps.velocity( vels );
    assert( vels.length() == count );
    for( i=0; i<vels.length(); i++ )
    {
        const MVector& v = vels[i];
        sprintf( buffer, "vel %f %f %f  ", v[0], v[1], v[2] );
        MGlobal::displayInfo( buffer );
    }

    MVectorArray accs;
    ps.acceleration( accs );
    assert( accs.length() == count );
    for( i=0; i<accs.length(); i++ )
    {
        const MVector& a = accs[i];
        sprintf( buffer, "acc %f %f %f  ", a[0], a[1], a[2] );
        MGlobal::displayInfo( buffer );
    }

    bool flag = ps.isDeformedParticleShape(&stat);
    CHECKRESULT(stat,"MFnParticleSystem::isDeformedParticleShape() failed!");
    if( flag ) {
            MObject obj = ps.originalParticleShape(&stat);
        CHECKRESULT(stat,"MFnParticleSystem::originalParticleShape() failed!");
        if( obj != MObject::kNullObj ) {
                MFnParticleSystem ps( obj );
            sprintf( buffer, "original particle shape : %s ", ps.particleName().asChar() );
            MGlobal::displayInfo( buffer );
        }
    }

    flag = ps.isDeformedParticleShape(&stat);
    CHECKRESULT(stat,"MFnParticleSystem::isDeformedParticleShape() failed!");
    if( !flag ) {
            MObject obj = ps.deformedParticleShape(&stat);
        CHECKRESULT(stat,"MFnParticleSystem::deformedParticleShape() failed!");
        if( obj != MObject::kNullObj ) {
                MFnParticleSystem ps( obj );
            sprintf( buffer, "deformed particle shape : %s ", ps.particleName().asChar() );
            MGlobal::displayInfo( buffer );
        }
    }

    if( ids.length() == positions.length() &&
        ids.length() == vels.length()      &&
        ids.length() == accs.length()       ) { 
            setResult( int(ids.length()) );
    } else {
            setResult( int(-1) );
    }

    return MS::kSuccess;
}


//
//

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


MStatus initializePlugin( MObject obj )
{
    MFnPlugin plugin( obj, PLUGIN_COMPANY, "4.5", "Any");

    MStatus status = plugin.registerCommand(mCommandName,
                                            particleSystemInfoCmd::creator );
    if (!status) 
        status.perror("registerCommand");

    return status;
}


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

    MStatus status = plugin.deregisterCommand(mCommandName);
    if (!status) 
        status.perror("deregisterCommand");

    return status;
}