- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

# simpleLoftNode.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 <string.h>
    #include <maya/MIOStream.h>
    #include <math.h>

    #include <maya/MPxNode.h>
    #include <maya/MPxCommand.h>

    #include <maya/MFnNumericAttribute.h>
    #include <maya/MFnTypedAttribute.h>
    #include <maya/MFnPlugin.h>

    #include <maya/MFnNurbsCurve.h>
    #include <maya/MFnNurbsSurface.h>
    #include <maya/MFnNurbsCurveData.h>
    #include <maya/MFnNurbsSurfaceData.h>

    #include <maya/MPointArray.h>
    #include <maya/MDoubleArray.h>

    #include <maya/MString.h>
    #include <maya/MTypeId.h>
    #include <maya/MPlug.h>
    #include <maya/MDataBlock.h>
    #include <maya/MDataHandle.h>

    #include <maya/MGlobal.h>
    #include <maya/MItCurveCV.h>
    #include <maya/MDagPath.h>

    class simpleLoft : public MPxNode
    {
    public:
                            simpleLoft() {};
        virtual             ~simpleLoft();

        virtual MStatus     compute( const MPlug& plug, MDataBlock& data );
        MObject             loft( MObject &curve, MObject &surfFn, MStatus &stat );

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

    public:
        static  MObject     inputCurve;     // The input curve.
        static  MObject     outputSurface;  // The output curve.
        static  MTypeId     id;             // The IFF type id
    };

    MTypeId     simpleLoft::id( 0x80011 );
    MObject     simpleLoft::inputCurve;
    MObject     simpleLoft::outputSurface;

    simpleLoft::~simpleLoft() {}

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

    MStatus simpleLoft::initialize()
    {
        MFnTypedAttribute   typedAttr;
        MStatus             stat;

        inputCurve = typedAttr.create( "inputCurve", "in",
                     MFnNurbsCurveData::kNurbsCurve, &stat );

        if ( !stat ) {
            stat.perror("ERROR creating simpleLoft curve attribute");
            return stat;
        }

        outputSurface = typedAttr.create( "outputSurface", "out",
                    MFnNurbsSurfaceData::kNurbsSurface, &stat );

        if ( !stat ) {
            stat.perror("ERROR creating simpleLoft surface attribute");
            return stat;
        }
        typedAttr.setStorable( false );

        stat = addAttribute( inputCurve );
            if (!stat) { stat.perror("addAttribute"); return stat;}
        stat = addAttribute( outputSurface );
            if (!stat) { stat.perror("addAttribute"); return stat;}

        stat = attributeAffects( inputCurve, outputSurface );
            if (!stat) { stat.perror("attributeAffects"); return stat;}

        return MS::kSuccess;
    }

    MObject simpleLoft::loft( MObject &curve, MObject &newSurfData, MStatus &stat )
    {
        MFnNurbsSurface surfFn;

        MPointArray cvs;
        MDoubleArray ku, kv;
        MFnNurbsCurve curveFn (curve);

        stat = curveFn.getCVs (cvs, MSpace::kWorld);
        if ( stat != MS::kSuccess )
        {
            cerr << "Error in getting CVs: " << stat << endl;
            return MObject::kNullObj;
        }

        int i, j, k = cvs.length();

        // create knot vectors for U and V

        ku.append( 0.0 );
        ku.append( 0.0 );
        ku.append( 0.0 );

        ku.append( 1.0 );
        ku.append( 1.0 );
        ku.append( 1.0 );

        kv.append( 0.0 );
        kv.append( 0.0 );
        kv.append( 0.0 );

        for ( i = 1; i < k-3; i ++ )
            kv.append( (double) i );

        kv.append( k-3 );
        kv.append( k-3 );
        kv.append( k-3 );

        // create cvs for the surface

        for ( i = 1; i < 4; i++ )
        {
            for ( j = 0; j < k; j++ )
            {
                MPoint point = cvs[j];
                point.z += (double) i;  // loft in Z by 1
                cvs.append( point );
            }
        }

        MObject surf = surfFn.create(
            cvs, ku, kv, 3, 3,
            MFnNurbsSurface::kOpen, MFnNurbsSurface::kOpen,
            false, newSurfData, &stat );

        if ( stat != MS::kSuccess )
        {
            cerr << "Error in creating surface: " << stat << endl;
            return MObject::kNullObj;
        }

        // stat = MGlobal::addToModel( surf );
        return surf;

    }

    MStatus simpleLoft::compute( const MPlug& plug, MDataBlock& data )
    {
        MStatus stat;

        if ( plug == outputSurface )    // loft inputCurve into surface
        {
            MDataHandle inputData = data.inputValue( inputCurve, &stat );
            if( stat != MS::kSuccess )
            {
                cerr << "ERROR getting data: " << stat << endl;
                return stat;
            }

            MObject curve = inputData.asNurbsCurve();
            MFnNurbsCurve curveFn( curve, &stat );
            if( stat != MS::kSuccess )
            {
              cerr << "ERROR creating curve function set:" << stat << endl;
              return stat;
            }

            MDataHandle surfHandle = data.outputValue( simpleLoft::outputSurface );
            if( stat != MS::kSuccess )
            {
              cerr << "Error in getting data handle: " << stat << endl;
              return stat;
            }

            MFnNurbsSurfaceData dataCreator;
            MObject newSurfData = dataCreator.create( &stat );
            if ( stat != MS::kSuccess ) {
              cerr << "Error creating new nurbs surface data block: "
                   << stat << endl;
              return stat;
            }

            /* MObject newSurf = */ loft( curve, newSurfData,  stat );
            if( stat != MS::kSuccess )
            {
              cerr << "Error in creating surface: " << stat << endl;
              return stat;
            }

            // newSurf is the new surface object, but it has been packed
            // into the datablock we created for it, and the data block
            // is what we must put onto the plug.
            surfHandle.set( newSurfData );

            stat = data.setClean( plug );
            if( stat != MS::kSuccess )
            {
              cerr << "Error in cleaning outputSurface plug: "
                   << stat << endl;
              return stat;
            }
        }
        else
        {
            return MS::kUnknownParameter;
        }

        return MS::kSuccess;
    }

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

        status = plugin.registerNode( "simpleLoft", simpleLoft::id,
                                      simpleLoft::creator, simpleLoft::initialize );
        if (!status) {
            status.perror("registerNode");
            return status;
        }

        return status;
    }

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

        status = plugin.deregisterNode( simpleLoft::id );
        if (!status) {
            status.perror("deregisterNode");
            return status;
        }

        return status;
    }