cgfxShaderCmd.cpp
 
 
 
cgfxShaderCmd.cpp
//
// Copyright (C) 2002-2004 NVIDIA 
// 
// File: cgfxShaderCmd.cpp
//
// MEL Command: cgfxShader
//
// Author: Jim Atkinson
//
// Changes:
//  10/2003  Kurt Harriman - www.octopusgraphics.com +1-415-893-1023
//           - Multiple UV sets; user-specified texcoord assignment;
//             error handling.
//           - "-pp/pluginPath" flag of cgfxShader command returns the
//             full path of the "cgfxShader" subdirectory beneath the
//             directory from which the plug-in binary was loaded.
//           - "-mtc/maxTexCoords" flag of cgfxShader command returns an
//             upper bound on the number of texcoord inputs per vertex
//             (GL_MAX_TEXTURE_UNITS) that can be passed from Maya thru
//             OpenGL to vertex shaders on the current workstation.
//           - "-tcs/texCoordSource" flag of cgfxShader command returns
//             cgfxShader node's "tcs/texCoordSource" attribute value.  
//           - "-euv/emptyUV" and "-eus/emptyUVShapes" flags added as
//             part of a temporary workaround for a bug discovered in
//             Maya 5.0.  May be removed after Maya is fixed, so don't
//             rely on them in user code.  
//  12/2003  Kurt Harriman - www.octopusgraphics.com +1-415-893-1023
//           - To load or reload an effect, use the cgfxShader command
//             "-fx/fxFile <filename>" flag.  Setting the cgfxShader
//             node's "s/shader" attribute no longer loads the effect.
//           - Shader parameter descriptions can be queried via the
//             "-des/description" flag of cgfxShader command, together
//             with "-lp/listParameters" or "-p/parameter <name>"
//           - "-ci/caseInsensitive" option for "-p/parameter <name>"
//           - The techniques defined by the current effect can be
//             queried via the "-lt/listTechniques" flag.
//           - To choose a technique, set the "t/technique"
//             attribute of the cgfxShader node.  The effect is not 
//             reloaded.  There is no longer a message box requiring
//             the user to choose a technique when loading an effect.
//           - Fixed some undo/redo bugs that caused crashes and
//             incorrect rendering.  Fixed some memory leaks.
//
//-
// ==========================================================================
// 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 "cgfxShaderCommon.h"

#include "cgfxShaderCmd.h"
#include "cgfxShaderNode.h"
#include "cgfxProfile.h"
#include "cgfxFindImage.h"

#include <maya/MArgDatabase.h>
#include <maya/MCommandResult.h>
#include <maya/MDagPath.h>
#include <maya/MFeedbackLine.h>
#include <maya/MFnDagNode.h>
#include <maya/MGlobal.h>

#include <Cg/cg.h>
#if defined(WIN32) || defined(LINUX)
                #include <GL/gl.h>
#else
#if !OSMac_X86_64_
                #include <AGL/agl.h>
#else
        #include <OpenGL/gl.h>
#endif
#endif
#include <GL/glext.h>

// These options are global to the plug-in and don't require a
// node to be selected or specified...

#define kMaxTexCoordsFlag           "-mtc"
#define kMaxTexCoordsFlagLong       "-maxTexCoords"

#define kPluginPathFlag             "-pp"
#define kPluginPathFlagLong         "-pluginPath"

// These options pertain to the specified or selected cgfxShader node...

#define kFxFlag                                     "-fx"
#define kFxFlagLong                                 "-fxFile"

#define kFxPathFlag                                 "-fxp"
#define kFxPathFlagLong                     "-fxPath"

#define kFxTechniqueFlag                    "-t"
#define kFxTechniqueFlagLong        "-technique"

#define kFxProfileFlag                  "-pr"
#define kFxProfileFlagLong              "-profile"

#define kNameFlag                                   "-n"
#define kNameFlagLong                       "-name"

#define kListTechniquesFlag         "-lt"
#define kListTechniquesFlagLong     "-listTechniques"

#define kListProfilesFlag           "-lpr"
#define kListProfilesFlagLong       "-listProfiles"

#define kListParametersFlag                 "-lp"
#define kListParametersFlagLong     "-listParameters"

#define kParameterFlag                      "-p"
#define kParameterFlagLong                  "-parameter"

#define kTexCoordSourceFlag         "-tcs"
#define kTexCoordSourceFlagLong     "-texCoordSource"

#if MAYA_API_VERSION >= 700

        #define kColorSourceFlag         "-cs"
        #define kColorSourceFlagLong     "-colorSource"

#endif

#define kEmptyUVFlag                "-euv"
#define kEmptyUVFlagLong            "-emptyUV"

#define kEmptyUVShapesFlag          "-eus"
#define kEmptyUVShapesFlagLong      "-emptyUVShapes"

// Flags that modify the behavior of -lp ...

#define kCaseInsensitiveFlag        "-ci"
#define kCaseInsensitiveFlagLong    "-caseInsensitive"

// Flags that modify the behavior of -lp and -p ...

#define kDescriptionFlag            "-des"
#define kDescriptionFlagLong        "-description"



//
// Static data members
//
MString cgfxShaderCmd::sPluginPath;    // directory path for scripts etc.



MStatus
cgfxShaderCmd::doIt( const MArgList& args )
{
        MStatus stat;
        try
        {
                stat = doCmd( args );
        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                reportInternalError( __FILE__, (size_t)e );
                stat = MS::kFailure;
        }
        catch ( ... )
        {
                reportInternalError( __FILE__, __LINE__ );
                stat = MS::kFailure;
        }
        return stat;
}                                      // MStatus cgfxShaderCmd::doIt


MStatus
cgfxShaderCmd::redoIt()
{
#ifdef KH_DEBUG
        MString ss = "  .. Redo ";
        ss += fArgString;
        ss += "\n";
        ::OutputDebugString( ss.asChar() );
#endif

        MStatus stat;
        try
        {
                // Get the node object from the selection list.
                MObject oNode;
                stat = fNodeSelection.getDependNode( 0, oNode );
                M_CHECK( stat );

                MFnDependencyNode fnNode( oNode, &stat );
                M_CHECK( stat && fnNode.typeId() == cgfxShaderNode::sId );

                cgfxShaderNode* pNode = (cgfxShaderNode*)fnNode.userNode();
                M_CHECK( pNode );

                // Re-create or re-edit the node.
                stat = redoCmd( oNode, fnNode, pNode );
        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                reportInternalError( __FILE__, (size_t)e );
                stat = MS::kFailure;
        }
        catch ( ... )
        {
                reportInternalError( __FILE__, __LINE__ );
                stat = MS::kFailure;
        }
#ifdef KH_DEBUG
        ss = "  .. redone\n";
        ::OutputDebugString( ss.asChar() );
#endif
        return stat;
}                                      // MStatus cgfxShaderCmd::redoIt


MStatus
cgfxShaderCmd::undoIt()
{
#ifdef KH_DEBUG
        MString ss = "  .. Undo ";
        ss += fArgString;
        ss += "\n";
        ::OutputDebugString( ss.asChar() );
#endif

        MStatus stat;
        try
        {
                stat = undoCmd();
        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                reportInternalError( __FILE__, (size_t)e );
                stat = MS::kFailure;
        }
        catch ( ... )
        {
                reportInternalError( __FILE__, __LINE__ );
                stat = MS::kFailure;
        }
#ifdef KH_DEBUG
        ss = "  .. undone\n";
        ::OutputDebugString( ss.asChar() );
#endif
        return stat;
}                                      // MStatus cgfxShaderCmd::undoIt


MStatus
cgfxShaderCmd::doCmd(const MArgList& args)
//
//      Description:
//              implements the MEL cgfxShader command.
//
//      Arguments:
//              -fx/fxFile      The CgFX file to load.
//              -e/edit         Edit an existing cgfxShader rather than creating
//                                      a new one.
//      -q/query    Get specified info
//
//      Return Value:
//              MS::kSuccess - command succeeded
//              MS::kFailure - command failed (returning this value will cause the 
//                     MEL script that is being run to terminate unless the
//                     error is caught using a "catch" statement.
//
{
        // Get the current state of the flag
        // and store it in a temporary variable
        // static int tmpFlag = -1;

#if defined(_WIN32) && defined(CGFX_DEBUG_MEMORY)
        if (tmpFlag == -1)
        {
                tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );

                // Turn On (OR) - call _CrtCheckMemory at every
                // allocation request
                tmpFlag |= _CRTDBG_CHECK_ALWAYS_DF;

                // Turn on (OR) - check for memory leaks at end
                // of program.
                tmpFlag |= _CRTDBG_LEAK_CHECK_DF;

                _CrtSetDbgFlag( tmpFlag );
        }
#endif /* _WIN32 && CGFX_DEBUG_MEMORY */

        MStatus        status;
        MSelectionList selList;
        MObject        oNode;
        MString        sResult;
        MStringArray   saResult;
        MString        sFeedback;
        MString        sTemp;
        MString        sWho = "cgfxShader : ";

        status = parseArgs(args, selList);
        if (!status)
        {
                return status;
        }

        // -pp / -pluginPath 
        //     Returns the directory path where this plug-in's auxiliary
        //     files, such as MEL scripts, are expected to be found.
        //     The path name is in Maya format ('/' delimited) with no
        //     trailing slash.  Result type is string.  (Query only)
        if ( fPluginPath )
        {
                setResult( sPluginPath );
                return MS::kSuccess;
        }

        // -lp / -listProfiles
    //  
        //     Return the names of the profiles supported on the current
        //     platform.
        //
        //     Each item in the result array has the form
        //         "VertexProfileName<,GeometryProfileName,FragmentProfileName"
        //
        //     Result type is string[].  (Query only; set internally)
        if ( fListProfiles )
        {
        setResult( cgfxProfile::getProfileList() );
                return status;
        }

        // -mtc / -maxTexCoords
        //     Returns the maximum number of texcoord inputs that can be
        //     passed to vertex shaders under the currently installed
        //     OpenGL implementation.  Returns 0 if the information is
        //     not available.  Result type is integer.  (Query only)
        //
        // Don't use GL_MAX_TEXTURE_UNITS as this does not provide a proper
        // count when the # of image or texcoord inputs differs
        // from the conventional (older) notion of texture unit. 
        //
        // Instead take the minimum of GL_MAX_TEXTURE_COORDS_ARB and
        // GL_MAX_TEXUTRE_IMAGE_UNITS_ARB according to the 
        // ARB_FRAGMENT_PROGRAM specification.
        if ( fMaxTexCoords )    
        {
                GLint     mtc = 0;
                M3dView vw = M3dView::active3dView( &status );
                if ( status &&
                        vw.beginGL() )
                {
                        glGetIntegerv( GL_MAX_TEXTURE_COORDS_ARB, &mtc );
                        GLint mic = 0;
                        glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &mic );
                        if (mic < mtc)
                                mtc = mic;

                        if ( mtc < 1 )
                                mtc = 1;
                        else if ( mtc > CGFXSHADERNODE_GL_TEXTURE_MAX )
                                mtc = CGFXSHADERNODE_GL_TEXTURE_MAX;
                        
                        vw.endGL();
                }
                setResult( (int)mtc );
                return MS::kSuccess;
        }

        // If edit or query, find the specified cgfxShaderNode.
        MFnDependencyNode fnNode;
        cgfxShaderNode*   pNode = NULL;
        if ( fIsEdit || fIsQuery )
        {
                // We are editing an existing node which must have been
                // provided in the args (or the current selection list).
                // Get the correct node name into fNodeName;
                //
                if (selList.length() != 1)
                {
                        status = MS::kNotFound;
                        return status;
                }

                // Get the name of the node into fNodeName so that it can
                // be saved for undo/redo
                //
                MStringArray tmpList;
                selList.getSelectionStrings(tmpList);
                fNodeName = tmpList[0];
                if ( fNodeName.length() ) 
                {
                        sWho += " \"";
                        sWho += fNodeName;
                        sWho += "\"";
                }

                status = selList.getDependNode(0, oNode);
                if (!status)
                {
                        return status;
                }

                status = fnNode.setObject( oNode );
                if (!status)
                {
                        sFeedback = sWho;
                        sFeedback += " is not a cgfxShader node.";
                        MGlobal::displayError( sFeedback );

                        return status;
                }

                if (fnNode.typeId() != cgfxShaderNode::sId)
                {
                        status = MS::kInvalidParameter;
                        sFeedback = sWho;
                        sFeedback += " is not a cgfxShader node.";
                        MGlobal::displayError( sFeedback );
                        return status;
                }

                pNode = (cgfxShaderNode*)fnNode.userNode();
                if (!pNode)
                {
                        status = MS::kInvalidParameter;
                        sFeedback = sWho;
                        sFeedback += " is not cgfxShader node.";
                        MGlobal::displayError( sFeedback );
                        return status;
                }
        }

        if ( fIsQuery ) {
        
        // -fx / -fxFile
        //     Returns the shader file name. 
        if ( fFxFile )
        {
            MString path = pNode->shaderFxFile();
            setResult( path );
            return MS::kSuccess;
        }

        // -fxp / -fxPath 
        //     Returns the path of the fx file.  The path name is in Maya
        //     format ('/' delimited).  Result type is string.
        //     (Query only)
        if ( fFxPath )
        {
            MString path = cgfxFindFile(pNode->shaderFxFile());
            setResult( path );
            return MS::kSuccess;
        }

        // -t / -technique
        //     Returns the currently active technique
        if ( fTechnique )
        {
            MString path = pNode->getTechnique();
            setResult( path );
            return MS::kSuccess;
        }

        // -p / -profile
        //     Returns the current profile
        if ( fProfile )
        {
            MString path = pNode->getProfile();
            setResult( path );
            return MS::kSuccess;
        }

        // -lt / -listTechniques
        //     Return the technique names defined by the current effect.
        //
        //     Each item in the result array has the form
        //         "techniqueName<TAB>numPasses"
        //     where 
        //         numPasses is the number of passes defined by the 
        //             technique, or 0 if the technique is not valid.   
        //     (Future versions of the cgfxShader plug-in may append
        //      additional tab-separated fields.)
        //
        //     Result type is string[].  (Query only; set internally)
        if ( fListTechniques )
        {
            setResult( pNode->getTechniqueList() );
            return status;
        }

        // -lp / -listParameters
        //     Return the attribute names corresponding to the
        //     shader's tweakable uniform parameters.
        //     Result type is string[].  (Query only; set internally)
        // -des / -description
        //     If specified, each item in the result array has the form
        //          "attrName<TAB>type<TAB>semantic<TAB>description<TAB>extraAttrSuffix"
        //     (Future versions of the cgfxShader plug-in may provide
        //       additional tab-separated fields after the semantic.)
        //     A missing field is indicated by a single space (" ") 
        //       so the string can be parsed more easily using the MEL
        //       "tokenize" function, which treats a group of consecutive
        //       delimiters the same as a single delimiter.
        if ( fListParameters )
        {
            cgfxRCPtr<cgfxAttrDefList> list = cgfxAttrDef::attrsFromNode( oNode );
            for ( cgfxAttrDefList::iterator it = list; it; ++it )
            {
                cgfxAttrDef* aDef = *it;
                if ( fDescription )
                {
                    sResult = aDef->fName.length() ? aDef->fName : " ";
                    sResult += "\t";
                    sTemp = aDef->typeName();
                    sResult += sTemp.length() ? sTemp : " ";
                    sResult += "\t";               
                    sResult += aDef->fSemantic.length() ? aDef->fSemantic : " ";
                    sResult += "\t";
                    sResult += aDef->fDescription.length() ? aDef->fDescription : " ";
                    sResult += "\t";               
                    const char* suffix = aDef->getExtraAttrSuffix();
                    sResult += suffix ? suffix : " ";
                }
                else
                    sResult = aDef->fName;
                saResult.append( sResult );
            }
            setResult( saResult );
            return status;
        }

        // -p  / -parameter <name>
        //     Return a string describing the data type and usage of 
        //     the attribute whose name is specified.  
        //     Result type is string (with no -description flag), or
        //     string array (if you specify -description).  
        //     (Query only; set internally)
        // -ci / -caseInsensitive
        //     If specified, returns information for the first 
        //     attribute that matches the specified name assuming
        //     no distinction between upper and lower case letters.
        // -des / -description
        //     If specified, the result is a string array containing:
        //          [0] = attribute name
        //          [1] = type
        //          [2] = semantic 
        //          [3] = description from "desc" or "uiname" annotation
        //          [4] = extra attribute suffix for Vector4 ("W") / Color4 ("Alpha")
        //          (Future versions of the cgfxShader plug-in may provide
        //          additional tab-separated fields after the semantic.)
        //     If omitted, only the type is returned (a string).
        if ( fParameterName.length() > 0 )
        {
            cgfxRCPtr<cgfxAttrDefList> list = cgfxAttrDef::attrsFromNode( oNode );
            cgfxAttrDefList::iterator it; 
            if ( fCaseInsensitive )
                it = list->findInsensitive( fParameterName );
            else
                it = list->find( fParameterName );
            if ( fDescription )
            {
                if ( it )
                {
                    cgfxAttrDef* aDef = *it;
                    saResult.append( aDef->fName );
                    saResult.append( aDef->typeName() );
                    saResult.append( aDef->fSemantic );
                    saResult.append( aDef->fDescription );
                    const char* suffix = aDef->getExtraAttrSuffix();
                    saResult.append( suffix ? suffix : "" );
                }
                setResult( saResult );
            }
            else
            {
                if ( it )
                    sResult = (*it)->typeName();
                setResult( sResult );
            }
            return status;
        }

        // -euv / -emptyUV
        //     Returns the names of blacklisted UV sets.  These UV sets
        //     are disabled from being passed to the shader because there
        //     is at least one mesh where the UV set name is defined but 
        //     has no faces mapped.  Due to a bug in Maya (in 5.0 and
        //     possibly some other releases), Maya crashes if an empty
        //     UV set is accessed by a hardware shader.  Blacklisting is
        //     intended to protect the user against accidentally hitting
        //     the bug and crashing Maya.  After the Maya fix has been
        //     verified, this option can continue to be accepted for awhile
        //     for compatibility, returning an empty result array.
        //     Result type is string[].  (Query only; set internally)
        if ( fEmptyUV )
        {
            setResult( pNode->getEmptyUVSets() );
            return MS::kSuccess;
        }

        // -eus / -emptyUVShapes
        //     Returns the names of shape nodes that have empty UV sets 
        //     which are causing the UV set names to be blacklisted.
        //     After the Maya bug fix has been verified, this option
        //     can remain for awhile for compatibility, returning an
        //     empty result array.
        //     Result type is string[].  (Query only; set internally)
        if ( fEmptyUVShapes )
        {
            const MObjectArray& oaShapes = pNode->getEmptyUVSetShapes();
            MFnDagNode          fnDagNode;
            MDagPath            dpShape;
            for ( unsigned iShape = 0; iShape < oaShapes.length(); ++iShape )
            {
                fnDagNode.setObject( oaShapes[ iShape ] );
                fnDagNode.getPath( dpShape );
                saResult.append( dpShape.partialPathName() );
            }
            setResult( saResult );
            return MS::kSuccess;
        }

        // -tcs / -texCoordSource
        //     Returns the value of the texCoordSource attribute, because
        //     the MEL "getAttr" command doesn't work with string arrays.
        //     Result type is string[].  (Query only; set via "setAttr")
        if ( fTexCoordSource )
        {
            setResult( pNode->getTexCoordSource() );
            return MS::kSuccess;
        }

#if MAYA_API_VERSION >= 700

        // -cs / -colorSource
        //     Returns the value of the colorSource attribute, because
        //     the MEL "getAttr" command doesn't work with string arrays.
        //     Result type is string[].  (Query only; set via "setAttr")
        if ( fColorSource )
        {
            setResult( pNode->getColorSource() );
            return MS::kSuccess;
        }

#endif

        // Error if -q with no other query flags.
                return MS::kInvalidParameter;
    }

        // If user didn't specify shader fx file, default to current
        // value of our cgfxShader node's "shader" attribute.
        if (!fFxFile && pNode)
                fNewFxFile = pNode->shaderFxFile();

        // If user didn't specify technique name, default to current
        // value of our cgfxShader node's "technique" attribute.
    //
    // If a new fx file has been specified without a technique, we
    // leave the technique name empty so that the first technique of
    // the effect will be selected.
        if (!fTechnique && pNode)
                fNewTechnique = pNode->getTechnique();

        // If user didn't specify profile name, default to current
        // value of our cgfxShader node's "profile" attribute.
        if (!fProfile && pNode)
                fNewProfile = pNode->getProfile();

        //
        // Load the effect from the .fx file.
        //
        if (fFxFile)
        {
                // Attempt to read the new fEffect from the file
                //
                MString file = cgfxFindFile(fNewFxFile);
        MString projectFile = cgfxFindFile(fNewFxFile, true);

                // Compile and create the effect.
                fNewEffect = cgfxEffect::loadEffect(file, cgfxProfile::getProfile(fNewProfile));

                if (fNewEffect->isValid())
                {           
                        // There is no current view in batch mode, just return
                        // success then
                        const MGlobal::MMayaState mayaState = MGlobal::mayaState(&status);
                        if ( !status ) return status;
                        if ( mayaState == MGlobal::kBatch ) return MS::kSuccess;

                        fNewFxFile = projectFile;

                        M3dView view = M3dView::active3dView();

                        // The M3dView class doesn't return the correct status if
                        // there isn't an active 3D view, so we rely on the
                        // success of beginGL() which will make the context
                        // current.
                        //
                        if (!view.beginGL()) 
                        {
                                MString es = "There is no active view to bind " + sWho + " to.";
                                MGlobal::displayWarning( es );
                                return MS::kSuccess;
                        }

                        view.endGL();
                }

                // Tell user if successful.
                if (fNewEffect->isValid())
                {
                        sFeedback = sWho;
                        sFeedback += " loaded effect \"";
                        sFeedback += file;
                        sFeedback += "\"";
                        MGlobal::displayInfo( sFeedback );
                }
                else
                {
                        sFeedback = sWho;
                        sFeedback += " unable to load effect \"";
                        sFeedback += file.length() ? file : fNewFxFile;
                        sFeedback += "\"";
                        MGlobal::displayError( sFeedback );
                        return MS::kFailure;
                }
        }

        // Create an MDGModifier to hold an agenda of operations to be
        //   performed to update the DG.  We build the agenda here;
        //   then invoke it to do/redo/undo the updates.
        fDagMod = new MDGModifier;

        // Create new cgfxShader node if requested.  
        if ( !fIsEdit )
        {
                // Create node.
                oNode = fDagMod->createNode(cgfxShaderNode::sId, &status);
                M_CHECK( status );

                if ( fNodeName.length() > 0 )
                {
                        status = fDagMod->renameNode(oNode, fNodeName);
                        M_CHECK( status );
                }

                status = fnNode.setObject( oNode );
                M_CHECK( status && fnNode.typeId() == cgfxShaderNode::sId );

                pNode = (cgfxShaderNode*)fnNode.userNode();
                M_CHECK( pNode );

                // On successful completion, redoCmd() will select the new node.
                // Save old selection for undo.
                status = MGlobal::getActiveSelectionList( fOldSelection );
                M_CHECK( status );
        }

        if (fFxFile) {
        // Save the current state of the node for undo purposes
        fOldFxFile    = pNode->shaderFxFile();
        fOldEffect = pNode->effect();   // save old CGeffect

                cgfxShaderNode::NodeList nodes;
                // getNodesToUpdate will return the list of nodes that will need to be updated :
                // if the new fx file is the same as the old fx file, the action is considered a reload,
                //     we'll gather all the nodes that are using the old effect and reload them all.
                // else the effect file is different and only the current node will be updated.
                getNodesToUpdate(fOldEffect, pNode, nodes);

                cgfxShaderNode::NodeList::const_iterator it = nodes.begin();
                cgfxShaderNode::NodeList::const_iterator itEnd = nodes.end();
                for(; it != itEnd; ++it)
                {
                        cgfxShaderNode* node = *it;

                        MStringArray &oldAttributeList = fOldAttributeList[node];
                        cgfxRCPtr<cgfxAttrDefList> &oldAttrDefList = fOldAttrDefList[node];

                        MStringArray &newAttributeList = fNewAttributeList[node];
                        cgfxRCPtr<cgfxAttrDefList> &newAttrDefList = fNewAttrDefList[node];


                        node->getAttributeList( oldAttributeList );

                        oldAttrDefList = node->attrDefList(); // save old cgfxAttrDefList ptr

                        // Now figure out what to do with the node.
                        //
                        // updateNode does a fair amount of work.  First, it gets the
                        // cgfxAttrDefList from the effect.  Then it gets the equivalent
                        // list from the node itself.  It determines which attributes need
                        // to be added and which need to be deleted and fills in all the
                        // changes in the MDagModifier fDagMod.  Then it builds a new value
                        // for the attributeList attribute.  Finally, it builds a new
                        // value for the attrDefList internal value.  All these values are
                        // returned here where we can set them into the node.
                        //
                        cgfxAttrDef::updateNode( fNewEffect,             // IN
                                                                         node,                   // IN
                                                                         fDagMod,                // UPD
                                                                         newAttrDefList,         // OUT
                                                                         newAttributeList );     // OUT
                }
    }

        // Save a reference to the node in a selection list for undo/redo.
        status = fNodeSelection.add( oNode );
        M_CHECK( status );

        // Save the current state of the node for undo purposes
        fOldTechnique = pNode->getTechnique();
        fOldProfile   = pNode->getProfile();

        // I think we have all the information to redoIt().
        //
        // Typically, the doIt() method only collects the infomation required
        // to do/undo the action and then stores it in class members.  The 
        // redo method is then called to do the actuall work.  This prevents
        // code duplication.
        //
        return redoCmd( oNode, fnNode, pNode );
}                                      // cgfxShaderCmd::doCmd


//      Description:
//              implements redo for the MEL cgfxShader command. 
//
//              This method is called when the user has undone a command of this type
//              and then redoes it.  No arguments are passed in as all of the necessary
//              information is cached by the doIt method.
//
//      Return Value:
//              MS::kSuccess - command succeeded
//              MS::kFailure - redoIt failed.  this is a serious problem that will
//                     likely cause the undo queue to be purged
MStatus
cgfxShaderCmd::redoCmd( MObject&           oNode,
                        MFnDependencyNode& fnNode,
                        cgfxShaderNode*    pNode )
{
        MStatus status;


    if (!fOldAttrDefList.empty()) {
        // Release the textures from the innactive attribute list to
        // save memory.
                NodeAttrDefList::iterator it = fOldAttrDefList.begin();
                NodeAttrDefList::iterator itEnd = fOldAttrDefList.end();
                for(; it != itEnd; ++it)
                {
                        cgfxRCPtr<cgfxAttrDefList> &attrDefList = it->second;
                        if(!attrDefList.isNull())
                                attrDefList->releaseTextures();
                }
    }

    if (fFxFile) {
        // cgfxAttrDef list may contain MObject references to dynamic attrs
        //   that are about to disappear.  Clean up those references before 
        //   they become invalid, so they don't cause an exception later.
        pNode->setAttrDefList( cgfxRCPtr<cgfxAttrDefList>() );
                cgfxRCPtr<cgfxAttrDefList> currNodeAttrDefList;

        // Actually update the node.
        status = fDagMod->doIt();
        M_CHECK( status );

                cgfxShaderNode::NodeList nodes;
                // getNodesToUpdate will return the list of nodes that will need to be updated :
                // if the new fx file is the same as the old fx file, the action is considered a reload,
                //     we'll gather all the nodes that are using the old effect and reload them all.
                // else the effect file is different and only the current node will be updated.
                getNodesToUpdate(fOldEffect, pNode, nodes);

                cgfxShaderNode::NodeList::const_iterator it = nodes.begin();
                cgfxShaderNode::NodeList::const_iterator itEnd = nodes.end();
                for(; it != itEnd; ++it)
                {
                        cgfxShaderNode* node = *it;

                        MStringArray &attributeList = fNewAttributeList[node];
                        cgfxRCPtr<cgfxAttrDefList> &attrDefList = fNewAttrDefList[node];

                        if(node == pNode)
                                currNodeAttrDefList = attrDefList;

                        node->setAttributeList(attributeList);
                        node->setAttrDefList(attrDefList);
                        // Notice: Must setShaderFxFileChanged before setEffect
                        node->setShaderFxFileChanged(true);
                        node->setEffect(fNewEffect);
                }

        cgfxAttrDef::initializeAttributes( oNode, currNodeAttrDefList, false, fDagMod);
        fnNode.findPlug( cgfxShaderNode::sShader ).setValue( fNewFxFile );
    }
    else {
        // Actually update the node.
        status = fDagMod->doIt();
        M_CHECK( status );
    }

    if (fTechnique) {
        fnNode.findPlug( cgfxShaderNode::sTechnique ).setValue( fNewTechnique );
    }

    if (fProfile) {
        fnNode.findPlug( cgfxShaderNode::sProfile ).setValue( fNewProfile );
    }

        if ( !fIsEdit ) 
        {
                // Save the actual node name (in case user did not specify a
                //   name, or in case Maya altered the name to make it unique.)
                fNodeName = fnNode.name();

                // Finally, if we created a new node, select it.  I don't do
                // status checking here because I don't want the command to fail
                // merely because the selection might fail.  In other words, I'm
                // not checking because I don't care.
                //
                MSelectionList selList;
                selList.add(oNode);
                MGlobal::setActiveSelectionList(selList);
        }

        return MS::kSuccess;
}                                      // cgfxShaderCmd::redoCmd


MStatus
cgfxShaderCmd::undoCmd()
//
//      Description:
//              implements undo for the MEL cgfxShader command.  
//
//              This method is called to undo a previous command of this type.  The 
//              system should be returned to the exact state that it was it previous 
//              to this command being executed.  That includes the selection state.
//
//      Return Value:
//              MS::kSuccess - command succeeded
//              MS::kFailure - undo failed.  this is a serious problem that will
//                     likely cause the undo queue to be purged
//
{
        MStatus status;

        // Find the node
        //
        MObject oNode;

        status = fNodeSelection.getDependNode(0, oNode);
        M_CHECK( status );

        MFnDependencyNode fnNode( oNode, &status );
        M_CHECK( status && fnNode.typeId() == cgfxShaderNode::sId );

        cgfxShaderNode* pNode = (cgfxShaderNode*)fnNode.userNode();
        M_CHECK( pNode );


    if (!fNewAttrDefList.empty()) {
        // Release the textures from the innactive attribute list to
        // save memory.
                NodeAttrDefList::iterator it = fNewAttrDefList.begin();
                NodeAttrDefList::iterator itEnd = fNewAttrDefList.end();
                for(; it != itEnd; ++it)
                {
                        cgfxRCPtr<cgfxAttrDefList> &attrDefList = it->second;
                        if(!attrDefList.isNull())
                                attrDefList->releaseTextures();
                }
    }

    if (fFxFile) {
        // cgfxAttrDef list may contain MObject references to dynamic attrs
        //   that are about to disappear.  Clean up those references before 
        //   they become invalid, so they don't cause an exception later.
        pNode->setAttrDefList( cgfxRCPtr<cgfxAttrDefList>() );
    }
    
        // Now put the node back the way it used to be.
        //
        status = fDagMod->undoIt();
        M_CHECK( status );

        if ( fIsEdit )
        {
        if (fFxFile) {
                        cgfxRCPtr<cgfxAttrDefList> currNodeAttrDefList;

                        cgfxShaderNode::NodeList nodes;
                        // getNodesToUpdate will return the list of nodes that will need to be updated :
                        // if the new fx file is the same as the old fx file, the action is considered a reload,
                        //     we'll gather all the nodes that are using the nex effect (it's an undo) and reload them all.
                        // else the effect file is different and only the current node will be updated.
                        getNodesToUpdate(fNewEffect, pNode, nodes);

                        cgfxShaderNode::NodeList::const_iterator it = nodes.begin();
                        cgfxShaderNode::NodeList::const_iterator itEnd = nodes.end();
                        for(; it != itEnd; ++it)
                        {
                                cgfxShaderNode* node = *it;

                                MStringArray &attributeList = fOldAttributeList[node];
                                cgfxRCPtr<cgfxAttrDefList> &attrDefList = fOldAttrDefList[node];

                                if(node == pNode)
                                        currNodeAttrDefList = attrDefList;

                                node->setAttributeList(attributeList);
                                node->setAttrDefList(attrDefList);
                                // Notice: Must setShaderFxFileChanged before setEffect
                                node->setShaderFxFileChanged(true);
                                node->setEffect(fOldEffect);

                        }
            cgfxAttrDef::initializeAttributes( oNode, currNodeAttrDefList, true, fDagMod);
            fnNode.findPlug( cgfxShaderNode::sShader ).setValue( fOldFxFile );
        }

        if (fTechnique) {
            fnNode.findPlug( cgfxShaderNode::sTechnique ).setValue( fOldTechnique );
        }
        if (fProfile) {
            fnNode.findPlug( cgfxShaderNode::sProfile ).setValue( fOldProfile );
        }
        }
        else 
        {
                MGlobal::setActiveSelectionList( fOldSelection );
        }

        return MS::kSuccess;
}                                      // cgfxShaderCmd::undoCmd


/* static */
MSyntax cgfxShaderCmd::newSyntax()
{
        MSyntax syntax;

        syntax.enableEdit();
        syntax.enableQuery();
        syntax.addFlag( kPluginPathFlag, kPluginPathFlagLong );
        syntax.addFlag( kMaxTexCoordsFlag, kMaxTexCoordsFlagLong );
        syntax.addFlag(kFxFlag, kFxFlagLong, MSyntax::kString);
        syntax.addFlag(kFxPathFlag, kFxPathFlagLong, MSyntax::kString);
        syntax.addFlag(kFxTechniqueFlag, kFxTechniqueFlagLong, MSyntax::kString);
        syntax.addFlag( kListTechniquesFlag, kListTechniquesFlagLong );
        syntax.addFlag(kFxProfileFlag, kFxProfileFlagLong, MSyntax::kString);
        syntax.addFlag( kListProfilesFlag, kListProfilesFlagLong );
        syntax.addFlag(kNameFlag, kNameFlagLong, MSyntax::kString);
        syntax.addFlag(kListParametersFlag, kListParametersFlagLong);
        syntax.addFlag(kParameterFlag, kParameterFlagLong, MSyntax::kString);
        syntax.addFlag( kEmptyUVFlag, kEmptyUVFlagLong );
        syntax.addFlag( kEmptyUVShapesFlag, kEmptyUVShapesFlagLong );
        syntax.addFlag( kTexCoordSourceFlag, kTexCoordSourceFlagLong );
#if MAYA_API_VERSION >= 700
        syntax.addFlag( kColorSourceFlag, kColorSourceFlagLong );
#endif
        syntax.addFlag( kCaseInsensitiveFlag, kCaseInsensitiveFlagLong );
        syntax.addFlag( kDescriptionFlag, kDescriptionFlagLong );

        syntax.setObjectType(MSyntax::kSelectionList, 0, 1);

        // Removed useSelectionAsDefault because in Maya 5.0 it causes an
        // unwanted error message to the Script Editor window from the
        // MArgDatabase constructor when no object is specified and the
        // current selection is empty.                      - kh 11/2003
        //      syntax.useSelectionAsDefault(true);

        return syntax;
}


void* cgfxShaderCmd::creator()
//
//      Description:
//              this method exists to give Maya a way to create new objects
//      of this type. 
//
//      Return Value:
//              a new object of this type
//
{
        return new cgfxShaderCmd();
}


cgfxShaderCmd::cgfxShaderCmd()
//
//      Description:
//              cgfxShaderCmd constructor
//
:   fIsEdit( false )
,   fIsQuery( false )
,   fMaxTexCoords( false )
,   fFxFile( false )
,   fFxPath( false )
,   fTechnique( false )
,   fProfile( false )
,   fPluginPath( false )
,   fEmptyUV( false )
,   fEmptyUVShapes( false )
,   fListParameters(false)
,   fListTechniques( false )
,   fListProfiles( false )
,   fTexCoordSource( false )
#if MAYA_API_VERSION >= 700
,   fColorSource( false )
#endif
,   fCaseInsensitive( false )
,   fDescription( false )
,       fOldEffect(0)
,       fNewEffect(0)
,       fDagMod(0)
{ /* Nothing left */ }


cgfxShaderCmd::~cgfxShaderCmd()
//
//      Description:
//              cgfxShaderCmd destructor
//
{
        try
        {
#ifdef KH_DEBUG
                if ( !fIsQuery )
                {
                        MString ss = "  .. ~cmd ";
                        ss += fArgString;
                        ss += "\n";
                        ::OutputDebugString( ss.asChar() );
                }
#endif
        fOldAttrDefList.clear();
        fNewAttrDefList.clear();

                delete fDagMod;
        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                reportInternalError( __FILE__, (size_t)e );
        }
        catch ( ... )
        {
                reportInternalError( __FILE__, __LINE__ );
        }
}


bool cgfxShaderCmd::isUndoable() const
//
//      Description:
//              this method tells Maya this command is undoable.  It is added to the 
//              undo queue if it is.
//
//      Return Value:
//              true if this command is undoable.
//
{
        return !fIsQuery;
}


/* private */
MStatus cgfxShaderCmd::parseArgs(const MArgList& args, MSelectionList& selList)
{
        MStatus         status;
        MString         sMsg;

        selList.clear();
        fArgString.clear();
        for ( unsigned iArg = 0; iArg < args.length(); ++iArg )
        {
                if ( iArg > 0 )
                        fArgString += " ";
                fArgString += args.asString( iArg );
        }

#ifdef KH_DEBUG
        MString ss = "  .. Cmd  ";
        ss += fArgString;
        ss += "\n";
        ::OutputDebugString( ss.asChar() );
#endif

        MArgDatabase argData( syntax(), args, &status );
        if ( !status )
                return status;

        bool bCgfxShaderNodeRequired = true;
        fIsEdit = argData.isEdit();
        fIsQuery = argData.isQuery();

        if ( argData.isFlagSet( kMaxTexCoordsFlag ) )       
        {
                bCgfxShaderNodeRequired = false;
                fMaxTexCoords = true;    
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kPluginPathFlag ) )       
        {
                bCgfxShaderNodeRequired = false;
                fPluginPath = true;    
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kEmptyUVFlag ) )       
        {
                fEmptyUV = true;    
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kEmptyUVShapesFlag ) )       
        {
                fEmptyUVShapes = true;    
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kTexCoordSourceFlag ) )       
        {
                fTexCoordSource = true;    
                fIsQuery = true;
        }

#if MAYA_API_VERSION >= 700

        if ( argData.isFlagSet( kColorSourceFlag ) )       
        {
                fColorSource = true;    
                fIsQuery = true;
        }

#endif

        if (argData.isFlagSet(kFxFlag))
        {
        fFxFile = true;
        if (!fIsQuery) {
            argData.getFlagArgument(kFxFlag, 0, fNewFxFile);
        }
        }

        if (argData.isFlagSet(kFxPathFlag))
        {
                fFxPath = true;
                fIsQuery = true;
        }

        if (argData.isFlagSet(kFxTechniqueFlag))
        {
        fTechnique = true;
        if (!fIsQuery) {
            argData.getFlagArgument( kFxTechniqueFlag, 0, fNewTechnique );
        }
        }

        if (argData.isFlagSet(kFxProfileFlag))
        {
        fProfile = true;
        if (!fIsQuery) {
            argData.getFlagArgument( kFxProfileFlag, 0, fNewProfile );
        }
        }

        if (argData.isFlagSet(kNameFlag))
        {
                argData.getFlagArgument(kNameFlag, 0, fNodeName);
        }

        if (argData.isFlagSet(kListParametersFlag))
        {
                fListParameters = true;
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kListTechniquesFlag ) )
        {
                fListTechniques = true;
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kListProfilesFlag ) )
        {
                bCgfxShaderNodeRequired = false;
                fListProfiles = true;
                fIsQuery = true;
        }

        if (argData.isFlagSet(kParameterFlag))
        {
                argData.getFlagArgument(kParameterFlag, 0, fParameterName);
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kCaseInsensitiveFlag ) )       
        {
                fCaseInsensitive = true;    
                fIsQuery = true;
        }

        if ( argData.isFlagSet( kDescriptionFlag ) )       
        {
                fDescription = true;    
                fIsQuery = true;
        }

        // Check for mutually exclusive flags.
        if ( fIsQuery &&
                fIsEdit )
        {
                MString es = "cgfxShader: invalid use of -e/-edit flag";
                MGlobal::displayError( es );
                return MS::kInvalidParameter;
        }

        // Get the objects on which to operate.
        if ( bCgfxShaderNodeRequired )
        {
                argData.getObjects(selList);
                if ( selList.length() == 0 )
                        MGlobal::getActiveSelectionList( selList );
                if ( selList.length() != 1 )
                {
                        sMsg = "Exactly one node must be specified or selected for command:  cgfxShader ";
                        sMsg += fArgString;
                        MGlobal::displayError( sMsg );
                        status = MS::kInvalidParameter;
                }
        }

        return status;
}

void cgfxShaderCmd::getNodesToUpdate(const cgfxRCPtr<const cgfxEffect>& effect, cgfxShaderNode* currNode, cgfxShaderNode::NodeList& nodes) const
{
        // Consider as a reload if the new and old fx file names are the same
        bool isReload = (fNewFxFile == fOldFxFile);

        if(isReload)
        {
                // Get all the shaders that use the old effect
                cgfxShaderNode::getNodesUsingEffect(effect, nodes);
        }
        else
        {
                // Simply update the current node
                nodes.insert(currNode);
        }
}

// Error reporting
void
cgfxShaderCmd::reportInternalError( const char* sFile, size_t errcode )
{
        MString es = "cgfxShader internal error ";
        es += (int)errcode;
        if ( this &&
                fArgString.length() > 0 )
        {
                es += " with args: ";
                es += fArgString;
        }
#ifdef _WINDOWS
        ::OutputDebugString( es.asChar() );
        ::OutputDebugString( "\n" );
#endif
        MGlobal::displayError( es );
}                                      // cgfxShaderCmd::reportInternalError