cgfxAttrDef.cpp
 
 
 
cgfxAttrDef.cpp
//
// Copyright (C) 2002-2004 NVIDIA 
// 
// File: cgfxAttrDef.cpp
//
// Author: Jim Atkinson
//
// cgfxAttrDef holds the "definition" of an attribute on a cgfxShader
// node.  This definition includes all the Maya attributes plus the
// CGeffect parameter index.
//
// Changes:
//  12/2003  Kurt Harriman - www.octopusgraphics.com +1-415-893-1023
//           - 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>"
//           - "uimin"/"uimax" annotations set numeric slider bounds.
//           - "uiname" annotation is used as parameter description 
//             if there is no "desc" annotation.
//           - Attribute bounds and initial values are updated when
//             effect is changed or reloaded.  
//           - When creating dynamic attributes for shader parameters,
//             make them keyable if type is bool, int, float or color.
//             Vector types other than colors are made keyable if
//             they have a "desc" or "uiname" annotation.
//           - Dangling references to deleted dynamic attributes
//             caused exceptions in MObject destructor, terminating
//             the Maya process.  This has been fixed.
//           - Fixed some undo/redo bugs that caused crashes and
//             incorrect rendering.  Fixed some memory leaks.
//           - Improved error handling.  Use M_CHECK for internal errors. 
//
//-
// ==========================================================================
// 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 <float.h>                     // FLT_MAX
#include <limits.h>                    // INT_MAX, INT_MIN
#include <string.h>

#include <maya/MIOStream.h>
#include <maya/MGlobal.h>
#include <maya/MString.h>
#include <maya/MStringArray.h>
#include <maya/MFnStringData.h>
#include <maya/MFnStringArrayData.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MFnCompoundAttribute.h>
#include <maya/MFnTypedAttribute.h>
#include <maya/MFnMatrixAttribute.h>
#include <maya/MDGModifier.h>
#include <maya/MFnMatrixData.h>
#include <maya/MPlugArray.h>
#include <maya/MItDependencyGraph.h>
#include <maya/MSelectionList.h>

#include "cgfxAttrDef.h"
#include "cgfxShaderNode.h"
#include "cgfxFindImage.h"
#include "cgfxTextureCache.h"


//
// Defines
//

#define N_MAX_STRING_LENGTH 1024


#ifdef _WIN32

#else
#       define stricmp  strcasecmp
#       define strnicmp strncasecmp
#endif


// Decide the symbol we use
const char cgfxAttrDef::fSymbol = '_';

// Constructor
cgfxAttrDef::cgfxAttrDef(CGparameter cgParameter)
: fType( kAttrTypeUnknown )
, fSize( 0 )
, fHint( kVectorHintNone )
, fNumericMin( NULL )
, fNumericMax( NULL )
, fNumericSoftMin( NULL )
, fNumericSoftMax( NULL )
, fUnits( MDistance::kInvalid )
, fNumericDef( NULL )
, fTextureMonitor(kNullCallback)
// , fParameterIndex( (LPCSTR)(-1) )
, fParameterHandle(0)
, fInvertMatrix( false )
, fTransposeMatrix( false )
, fTweaked( false )
, fInitOnUndo( false )
, fIsConvertedToInternal( false )
{
    fName = cgGetParameterName(cgParameter);
    fType = cgfxAttrDef::kAttrTypeOther;
    fSize = cgGetParameterRows(cgParameter) * cgGetParameterColumns(cgParameter);
    fParameterHandle = cgParameter;
    fSemantic = cgGetParameterSemantic(cgParameter);

    CGtype cgParameterType = cgGetParameterType(cgParameter);
    switch (cgParameterType)
    {
        case CG_BOOL    : fType = cgfxAttrDef::kAttrTypeBool; break ;
                case CG_INT             : fType = cgfxAttrDef::kAttrTypeInt; break ;
                case CG_HALF    :
                case CG_FLOAT :
#ifdef _WIN32
            if (stricmp(fSemantic.asChar() , "Time")==0)
                fType = cgfxAttrDef::kAttrTypeTime;
            else 
#endif
                fType = cgfxAttrDef::kAttrTypeFloat;
            break;
                case CG_HALF2                           :
                case CG_FLOAT2                  : 
            fType = cgfxAttrDef::kAttrTypeVector2; 
            break ;
                case CG_HALF3                           :
                case CG_FLOAT3                  : 
            fType = cgfxAttrDef::kAttrTypeVector3; 
            break ;
                case CG_HALF4                           :
                case CG_FLOAT4                  : 
            fType = cgfxAttrDef::kAttrTypeVector4; 
            break ;
                case CG_HALF4x4                 :
                case CG_FLOAT4x4                : 
            setMatrixType(cgParameter); 
            break ;
                case CG_STRING                  : 
            fType = cgfxAttrDef::kAttrTypeString; 
            break ;
                case CG_TEXTURE                 :
            // handled by setSamplerType()
            break ;
                case CG_SAMPLER1D               : 
                case CG_SAMPLER2D               :
                case CG_SAMPLER3D               :
                case CG_SAMPLERRECT :
                case CG_SAMPLERCUBE :
            setSamplerType(cgParameter);
            break ;
                case CG_ARRAY                           :
                case CG_STRUCT                  :
            break ;

                default                                                 : 
            MString msg = cgGetTypeString(cgParameterType);
            msg += " not yet supported";
            MGlobal::displayError(msg);
            M_CHECK( false );
    }

    if (fType == cgfxAttrDef::kAttrTypeVector3 ||
        fType == cgfxAttrDef::kAttrTypeVector4)
    {
        // Set the specific vector type
        //
        setVectorType(cgParameter);
    }

    // Now that we know something about this attribute, walk through
    // the annotations on the parameter and see if there is any
    // additional information we can find.
    //

    MString     sUIName;
        
    CGannotation cgAnnotation = cgGetFirstParameterAnnotation(cgParameter);
    while (cgAnnotation)
    {
        const char* annotationName              = cgGetAnnotationName(cgAnnotation);
        const char* annotationValue             = cgGetStringAnnotationValue(cgAnnotation);
        CGtype                  cgAnnotationType        = cgGetAnnotationType(cgAnnotation);

        if (stricmp(annotationName, "uihelp") == 0)
        {
            fDescription = MString(annotationValue);
        }
        else if (stricmp(annotationName, "uiname" ) == 0 )
        {
            sUIName = MString(annotationValue);
        }
        else if( stricmp( annotationName, "units") == 0)
        {
                        // Make sure units are converted to internal or not
                        // _XXX is a unit converted to internal
                        if ( fSymbol == annotationValue[0] ) 
                        {
                                fIsConvertedToInternal = true;
                                annotationValue++;
                        }
                        else
                        {
                                fIsConvertedToInternal = false;
                        }

            if( stricmp( annotationValue, "inches") == 0)
            {
                fUnits = MDistance::kInches;
            }
            else if( stricmp( annotationValue, "millimetres") == 0 || stricmp( annotationValue, "millimeters") == 0 || stricmp( annotationValue, "mm") == 0)
            {
                fUnits = MDistance::kMillimeters;
            }
            else if( stricmp( annotationValue, "centimetres") == 0 || stricmp( annotationValue, "centimeters") == 0 || stricmp( annotationValue, "cm") == 0)
            {
                fUnits = MDistance::kCentimeters;
            }
            else if( stricmp( annotationValue, "metres") == 0 || stricmp( annotationValue, "meters") == 0 || stricmp( annotationValue, "m") == 0)
            {
                fUnits = MDistance::kMeters;
            }
            else if( stricmp( annotationValue, "kilometres") == 0 || stricmp( annotationValue, "kilometers") == 0 || stricmp( annotationValue, "km") == 0)
            {
                fUnits = MDistance::kKilometers;
            }
            else if( stricmp( annotationValue, "feet") == 0)
            {
                fUnits = MDistance::kFeet;
            }
        }
        else if ((fType >= cgfxAttrDef::kAttrTypeFirstTexture &&
                  fType <= cgfxAttrDef::kAttrTypeLastTexture))
        {
            if (stricmp(annotationName, "resourcetype") == 0)
            {
                if (stricmp(annotationValue, "1d") == 0)
                {
                    fType = cgfxAttrDef::kAttrTypeColor1DTexture;
                }
                else if (stricmp(annotationValue, "2d") == 0)
                {
                    fType = cgfxAttrDef::kAttrTypeColor2DTexture;
                }
                else if (stricmp(annotationValue, "3d") == 0)
                {
                    fType = cgfxAttrDef::kAttrTypeColor3DTexture;
                }
                else if (stricmp(annotationValue, "cube") == 0)
                {
                    fType = cgfxAttrDef::kAttrTypeCubeTexture;
                }
                else if (stricmp(annotationValue, "rect") == 0)
                {
                    fType = cgfxAttrDef::kAttrTypeColor2DRectTexture;
                }
            }
            else if (stricmp(annotationName, "resourcename") == 0)
            {
                // Store the texture file to load as the
                // string default argument.  (I know, its kind
                // of a kludge; but if the texture attributes
                // were string values, it would be exactly
                // correct.
                //
                fStringDef = annotationValue;
            }
        }
        else if (cgAnnotationType == CG_BOOL )
        {}                     // no min/max for bool
        else if (stricmp(annotationName, "min") == 0 ||
                 stricmp(annotationName, "max") == 0 ||
                 stricmp(annotationName, "uimin") == 0 ||
                 stricmp(annotationName, "uimax") == 0 )
        {
            double * tmp = new double [fSize];

            switch (cgAnnotationType)
            {
                                case CG_INT:
                    {
                        // int* val = (int*) adesc.Value;
                        // for (int k = 0; k < fSize; ++k)
                        // {
                        //     tmp[k] = val[k];
                        // }
                        
                        int nValues;
                        const int* annotationValues = cgGetIntAnnotationValues(cgAnnotation, &nValues);
                        
                        for (int iValue = 0; iValue < nValues; ++iValue)
                            tmp[iValue] = static_cast<double>(annotationValues[iValue]);
                    }   
                    break;

                                case CG_FLOAT:
                    {
                        // float* val = (float*) adesc.Value;
                        // for (int k = 0; k < fSize; ++k)
                        // {
                        //     tmp[k] = val[k];
                        // }
                        int nValues;
                        const float* annotationValues = cgGetFloatAnnotationValues(cgAnnotation, &nValues);

                        for (int iValue = 0; iValue < nValues; ++iValue)
                            tmp[iValue] = static_cast<double>(annotationValues[iValue]);
                    }
                    break;

                                default:
                    // This is not a numeric attribute, reset tmp to NULL
                    delete [] tmp;
                    tmp = 0;
                    break;
            }

            if (stricmp(annotationName, "min") == 0)
            {
                fNumericMin = tmp;
            }
            else if (stricmp(annotationName, "max") == 0)
            {
                fNumericMax = tmp;
            }
            else if (stricmp(annotationName, "uimin") == 0)
            {
                fNumericSoftMin = tmp;
            }
            else 
            {
                fNumericSoftMax = tmp;
            }
        } // end of if (adesc.Name == "min"|"max")

        cgAnnotation = cgGetNextAnnotation(cgAnnotation);
    }

    // Enforce limits on colors if they do not already have them.
    if ( fType == cgfxAttrDef::kAttrTypeColor3 ||
         fType == cgfxAttrDef::kAttrTypeColor4 )
    {
        if ( !fNumericMin )
        {
            fNumericMin = new double[4];
            fNumericMin[0] = 0.0;
            fNumericMin[1] = 0.0;
            fNumericMin[2] = 0.0;
            fNumericMin[3] = 0.0;
        }
        if ( !fNumericMax )
        {
            fNumericMax = new double[4];
            fNumericMax[0] = 1.0;
            fNumericMax[1] = 1.0;
            fNumericMax[2] = 1.0;
            fNumericMax[3] = 1.0;
        }
    }

    // If no description, use UIName.
    if ( !fDescription.length() )
        fDescription = sUIName;

    // Now get the default values
    //
    double* tmp = new double [fSize];

    CGtype cgParameterBaseType = cgGetParameterBaseType(cgParameter);

    switch (cgParameterBaseType)
    {
                case CG_BOOL:
            {
                int val;
                if (cgGetParameterValueic(cgParameter, 1, &val) != 1)
                {
                    delete [] tmp;
                    tmp = 0;
                    break;
                }

                for (int k = 0; k < fSize; ++k)
                {
                    tmp[k] = val ? 1 : 0;
                }
            }
            break;

                case CG_INT:
            {
                int val;
                if (cgGetParameterValueic(cgParameter, 1, &val) != 1)
                {
                    delete [] tmp;
                    tmp = 0;
                    break;
                }

                for (int k = 0; k < fSize; ++k)
                {
                    tmp[k] = val;
                }
            }
            break;

                case CG_FLOAT:
            {
                if (fSize == 1)
                {
                    float val;
                    if (cgGetParameterValuefc(cgParameter, 1, &val) != 1)
                    {
                        delete [] tmp;
                        tmp = 0;
                        break;
                    }

                                        // If the value is a converted value, we need to convert it to one with unit 
                                        if( fIsConvertedToInternal)
                                        {
                                                val = (float)MDistance( val, MDistance::internalUnit()).as(fUnits);
                                        }
                    tmp[0] = val;
                }
                else if (fSize <= 4 || fType == cgfxAttrDef::kAttrTypeMatrix)
                {
                    float val[16];
                    if (fType == kAttrTypeMatrix)
                    {
                        cgGetMatrixParameterfc(cgParameter, val);
                    }
                    else
                    {
                        unsigned int vecSize = fSize;
                        cgGetParameterValuefc(cgParameter, vecSize, val);
                    }
                    /*if (result != S_OK)
                      {
                      delete [] tmp;
                      tmp = 0;
                      break;
                      }*/
                                         for (int k = 0; k < fSize; ++k)
                    {
                                                // If the value is a converted value, we need to convert it to one with unit 
                                                if( fIsConvertedToInternal)
                                                {
                                                        val[k] = (float)MDistance( val[k], MDistance::internalUnit()).as(fUnits);
                                                }
                        tmp[k] = val[k];
                    }
                                        
                }
            }
            break;

        case CG_STRING:
            {
#ifdef _WIN32
                LPCSTR val;
#else
                const char* val = NULL;
#endif
                val = cgGetStringParameterValue(cgParameter);

                fStringDef = val;
            }
            // Fall through into the default case to destroy the
            // numeric default value.
            //

                default:
            // We don't know what to do but there is no point in
            // keeping tmp around.
            //
            delete [] tmp;
            tmp = 0;
    }

    // Don't save initial value if it is zero (or identity matrix).
    if ( tmp )
    {
        int k;
        if ( fSize == 16 )
        {
            const double* d = &MMatrix::identity[0][0];
            for ( k = 0; k < fSize; ++k )
                if ( tmp[ k ] != d[ k ] )
                    break;
        }
        else
        {
            for ( k = 0; k < fSize; ++k )
                if ( tmp[ k ] != 0.0 )
                    break;
        }
        if ( k == fSize )
        {
            delete [] tmp;
            tmp = 0;
        }
    }

    fNumericDef = tmp;

};


cgfxAttrDef::cgfxAttrDef(
    const MString&          sAttrName,
    const cgfxAttrType      eAttrType,
    const MString&          sDescription,
    const MString&          sSemantic,
    MObject                 obNode,
    MObject                 obAttr
)
: fType( kAttrTypeUnknown )
, fSize( 0 )
, fHint( kVectorHintNone )
, fNumericMin( NULL )
, fNumericMax( NULL )
, fNumericSoftMin( NULL )
, fNumericSoftMax( NULL )
, fUnits( MDistance::kInvalid )
, fNumericDef( NULL )
, fTextureMonitor(kNullCallback)
// , fParameterIndex( (LPCSTR)(-1) )
, fParameterHandle(0)
, fInvertMatrix( false )
, fTransposeMatrix( false )
, fTweaked( false )
, fInitOnUndo( false )
, fIsConvertedToInternal(false)
{
    MStatus status;
    
    fName = sAttrName;
    fType = eAttrType;
    fDescription = sDescription;
    fSemantic = sSemantic;
    fAttr = obAttr;

    MFnCompoundAttribute fnCompound;
    MFnNumericAttribute  fnNumeric;
    MFnTypedAttribute    fnTyped;
    MFnMatrixAttribute   fnMatrix;

    MPlug   plug( obNode, obAttr );
    double  numericMin[4];
    double  numericMax[4];
    double  numericValue[4];
    bool    hasMin    = false;
    bool    hasMax    = false; 
    bool    isNumeric = false;

    // If compound attribute, get value and bounds of each element.
    if ( fnCompound.setObject( obAttr ) )
    {
        hasMin = true;
        hasMax = true;
        isNumeric = true;

        MObject      obChild;
        MStringArray saChild;
        int iChild;
        int nChild = fnCompound.numChildren();
        M_CHECK( nChild >= 2 && nChild <= 3 );
        for ( iChild = 0; iChild < nChild; ++iChild )
        {
            // Get child attribute.
            if ( iChild < 3 )
            {
                obChild = fnCompound.child( iChild, &status );
                M_CHECK( status );
            }

            status = fnNumeric.setObject( obChild );
            M_CHECK( status );

            // Min
            if ( fnNumeric.hasMin() )
                fnNumeric.getMin( numericMin[ iChild ] );
            else
                hasMin = false; 

            // Max
            if ( fnNumeric.hasMax() )
                fnNumeric.getMax( numericMax[ iChild ] );
            else
                hasMax = false; 

            // Value
            MPlug plChild( obNode, obChild );
            status = plChild.getValue( numericValue[ iChild ] );
            M_CHECK( status );

            // Check for 4-element vector.
            saChild.append( fnNumeric.name() );
            if ( iChild == 2 )
            {
                const char* suffix = NULL;
                if ( saChild[0] == sAttrName + "X" &&
                     saChild[1] == sAttrName + "Y" &&
                     saChild[2] == sAttrName + "Z" ) 
                    suffix = "W";
                else if ( saChild[0] == sAttrName + "R" &&
                          saChild[1] == sAttrName + "G" &&
                          saChild[2] == sAttrName + "B" ) 
                    suffix = "Alpha";
                if ( suffix )
                {
                    MString sName2 = sAttrName + suffix;
                    MFnDependencyNode fnNode(obNode);
                    obChild = fnNode.attribute( sName2, &status );
                    MFnNumericData::Type ndt = fnNumeric.unitType();
                    if ( status &&
                         fnNumeric.setObject( obChild ) &&
                         fnNumeric.unitType() == ndt )
                    {
                        fAttr2 = obChild;
                        nChild = 4;     // loop again to get extra attr
                    }
                }
            }
        }                          // loop over children
        fSize = nChild;
    }                              // compound 

    // Simple numeric attribute?  
    else if ( fnNumeric.setObject( obAttr ) )
    {
        MFnNumericAttribute fnNumeric( obAttr, &status );
        M_CHECK( status );

        

        fSize = 1;
        isNumeric = true;

        // Get min and max.
        if ( fnNumeric.hasMin() )
        {
            fnNumeric.getMin( numericMin[0] );
            hasMin = true;
        }
        if ( fnNumeric.hasMax() )
        {
            fnNumeric.getMax( numericMax[0] );
            hasMax = true;
        }

        // Get slider bounds.
        if ( fnNumeric.hasSoftMin() )
        {
            fNumericSoftMin = new double[1];
            fnNumeric.getSoftMin( fNumericSoftMin[0] );
        }
        if ( fnNumeric.hasSoftMax() )
        {
            fNumericSoftMax = new double[1];
            fnNumeric.getSoftMax( fNumericSoftMax[0] );
        }

        // Value 
        status = plug.getValue( numericValue[0] );
        M_CHECK( status );
    }                              // simple numeric

    // String attribute?
    else if (fnTyped.setObject( obAttr ) &&
             fnTyped.attrType() == MFnData::kString)
    {
        fSize = 1;
        status = plug.getValue( fStringDef );
        M_CHECK( status );
    }                           // string
    // Matrix attribute?
    else if (fnMatrix.setObject( obAttr ))
    {
        MObject obData;
        status = plug.getValue( obData );
        M_CHECK( status );
        MFnMatrixData fnMatrixData( obData, &status );
        M_CHECK( status );
        const MMatrix& mat = fnMatrixData.matrix( &status );
        M_CHECK( status );
        fSize = 16;
        fNumericDef = new double[ fSize ];
        const double* p = &mat.matrix[0][0];
        for ( int i = 0; i < 16; ++i )
            fNumericDef[ i ] = p[ i ];
        M_CHECK( status );
    }                           // matrix 
    // Mystified...
    else
        M_CHECK( false );
    

    // Store numeric value, min and max.
    if ( isNumeric )
    {
        fNumericDef = new double[ fSize ];
        memcpy( fNumericDef, numericValue, fSize * sizeof( numericValue[0] ) );
        if ( hasMin )
        {
            fNumericMin = new double[ fSize ];
            memcpy( fNumericMin, numericMin, fSize * sizeof( numericMin[0] ) );
        }
        if ( hasMax )
        {
            fNumericMax = new double[ fSize ];
            memcpy( fNumericMax, numericMax, fSize * sizeof( numericMax[0] ) );
        }
    }

    // set attribute flags
    setAttributeFlags();
}

// Destructor
cgfxAttrDef::~cgfxAttrDef()
{
        release();
        delete [] fNumericMin;
        delete [] fNumericMax;
        delete [] fNumericSoftMin;
        delete [] fNumericSoftMax;
        delete [] fNumericDef;
};


// Release any associated resources
void cgfxAttrDef::release()
{
        releaseTexture();
        releaseCallback();
}
void cgfxAttrDef::releaseTexture()
{
    fTexture = cgfxRCPtr<cgfxTextureCacheEntry>();
}

void cgfxAttrDef::releaseCallback()
{
        if( fTextureMonitor != kNullCallback)
        {
                MMessage::removeCallback( fTextureMonitor);
                fTextureMonitor = kNullCallback;
        }
}


// ================ cgfxAttrDef::setTextureType ================

// This method looks at the parameter data type, semantic, and
// annotation and determines
void cgfxAttrDef::setTextureType(CGparameter cgParameter)
{
        fType = kAttrTypeColor2DTexture;

        const char* semantic = cgGetParameterSemantic(cgParameter);

        if (!semantic) return;

        // We have to go thru semantics and annotations to find the type of the texture

        if (semantic)
        {
                if (stricmp(semantic, "normal") == 0)
                {
                        fType = kAttrTypeNormalTexture;
                }
                else if (stricmp(semantic, "height") == 0)
                {
                        fType = kAttrTypeBumpTexture;
                }
                else if (stricmp(semantic, "environment") == 0)
                {
                        fType = kAttrTypeEnvTexture;
                }
                else if (stricmp(semantic, "environmentnormal") == 0)
                {
                        fType = kAttrTypeNormalizationTexture;
                }
        }

        // Now browse through the annotations to see if there is anything
        // interesting there too.

        CGannotation cgAnnotation = cgGetFirstParameterAnnotation(cgParameter);
        while (cgAnnotation)
        {
                const char*     annotationName  = cgGetAnnotationName(cgAnnotation);
                const char* annotationValue = cgGetStringAnnotationValue(cgAnnotation);
                
                if (stricmp(annotationName, "resourcetype") == 0)
                {
                        if (stricmp(annotationValue, "1d") == 0)
                        {
                                fType = kAttrTypeColor1DTexture;
                        }
                        else if (stricmp(annotationValue, "2d") == 0)
                        {
                                fType = kAttrTypeColor2DTexture;
                        }
                        else if (stricmp(annotationValue, "rect") == 0)
                        {
                                fType = kAttrTypeColor2DRectTexture;
                        }
                        else if (stricmp(annotationValue, "3d") == 0)
                        {
                                fType = kAttrTypeColor3DTexture;
                        }
                        else if (stricmp(annotationValue, "cube") == 0)
                        {
                                fType = kAttrTypeCubeTexture;
                        }
                }
                else if (stricmp(annotationName, "resourcename") == 0)
                {
                        // Store the texture file to load as the
                        // string default argument.  (I know, its kind
                        // of a kludge; but if the texture attributes
                        // were string values, it would be exactly
                        // correct.
                        //
                        fStringDef = annotationValue;
                }
                else if (stricmp(annotationName, "uvlink") == 0)
                {
                        // Store the variable name of the input UV
                        // set that this texture is to be linked against.
                        fTextureUVLink = annotationValue;
                }

                cgAnnotation = cgGetNextAnnotation(cgAnnotation);
        }
}

void cgfxAttrDef::setSamplerType(CGparameter cgParameter)
{
        CGstateassignment cgStateAssignment = cgGetNamedSamplerStateAssignment(cgParameter, "texture");
        setTextureType(cgGetTextureStateAssignmentValue(cgStateAssignment));
}

void cgfxAttrDef::setMatrixType(CGparameter cgParameter)
{
        fType = kAttrTypeMatrix;

        const char* semantic = cgGetParameterSemantic(cgParameter);

        if (!semantic)
                return;

        if (stricmp(semantic, "world") == 0)
        {
                fType = kAttrTypeWorldMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldinverse") == 0)
        {
                fType = kAttrTypeWorldMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldtranspose") == 0)
        {
                fType = kAttrTypeWorldMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "worldinversetranspose") == 0)
        {
                fType = kAttrTypeWorldMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "worldview") == 0)
        {
                fType = kAttrTypeWorldViewMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldviewtranspose") == 0)
        {
                fType = kAttrTypeWorldViewMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "worldviewinverse") == 0)
        {
                fType = kAttrTypeWorldViewMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldviewinversetranspose") == 0)
        {
                fType = kAttrTypeWorldViewMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "worldviewprojection") == 0)
        {
                fType = kAttrTypeWorldViewProjectionMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldviewprojectiontranspose") == 0)
        {
                fType = kAttrTypeWorldViewProjectionMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "worldviewprojectioninverse") == 0)
        {
                fType = kAttrTypeWorldViewProjectionMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "worldviewprojectioninversetranspose") == 0)
        {
                fType = kAttrTypeWorldViewProjectionMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "view") == 0)
        {
                fType = kAttrTypeViewMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "viewinverse") == 0)
        {
                fType = kAttrTypeViewMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "viewtranspose") == 0)
        {
                fType = kAttrTypeViewMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "viewinversetranspose") == 0)
        {
                fType = kAttrTypeViewMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "projection") == 0)
        {
                fType = kAttrTypeProjectionMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "projectioninverse") == 0)
        {
                fType = kAttrTypeProjectionMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = false;
        }
        else if (stricmp(semantic, "projectiontranspose") == 0)
        {
                fType = kAttrTypeProjectionMatrix;
                fInvertMatrix = false;
                fTransposeMatrix = true;
        }
        else if (stricmp(semantic, "projectioninversetranspose") == 0)
        {
                fType = kAttrTypeProjectionMatrix;
                fInvertMatrix = true;
                fTransposeMatrix = true;
        }
}

// This routine returns true if the semantic value is known to refer
// to a color value instead of a positional value.  We determine that
// this is a color value because it uses one of the known names or it
// contains the string "color" or "colour" in it.
//
void cgfxAttrDef::setVectorType(CGparameter cgParameter)
{
#if 0
        // This variable is not used
        static char* colorList[] = 
        {
                "diffuse",
                "specular",
                "ambient",
                "emissive",
        };
#endif

        const char* semantic = cgGetParameterSemantic(cgParameter);

        if ((semantic == NULL || strcmp(semantic,"") == 0) == false)
        {
                // Check the semantic value to see if this is a color
                //
                if (stricmp(semantic, "diffuse") == 0 ||
                        stricmp(semantic, "specular") == 0 ||
                        stricmp(semantic, "ambient") == 0 ||
                        stricmp(semantic, "emissive") == 0)
                {
                        fType = (fSize == 3) ? kAttrTypeColor3 : kAttrTypeColor4;
                }
                else if (stricmp(semantic, "direction") == 0)
                {
                        fType = kAttrTypeFirstDir;
                }
                else if (stricmp(semantic, "position") == 0)
                {
                        fType = kAttrTypeFirstPos;
                }
        }


        CGannotation cgAnnotation = cgGetFirstParameterAnnotation(cgParameter);
        while (cgAnnotation)
        {
                const char*     annotationName  = cgGetAnnotationName(cgAnnotation);
                const char* annotationValue = cgGetStringAnnotationValue(cgAnnotation);
                
                if (stricmp(annotationName, "type") == 0)
                {
                        if (strlen(annotationValue) != 0)
                        {
                                if (stricmp(annotationValue, "color") == 0)
                                {
                                        fType = (fSize == 3) ? kAttrTypeColor3 : kAttrTypeColor4;
                                }
                        }
                }
                else if (stricmp(annotationName, "space") == 0)
                {
                        // we assume the attribute to be a direction if it doesn't have semantic to determine it.
                        // display a warning at the same time
                        if(fType != kAttrTypeFirstDir && fType != kAttrTypeFirstPos)
                        {
                                const MString warnMsg = fName + " has space annotation but doesn't have semantic to determine if it is a direction or position! Assuming it to be a direction. You'd better add a semantic for it!";
                                MGlobal::displayWarning(warnMsg);
                                fType = kAttrTypeFirstDir;
                        }
                                
                        if (stricmp(annotationValue, "world") == 0)
                        {
                                fType = (cgfxAttrType)(fType + kAttrTypeWorldDir - kAttrTypeFirstDir);
                        }
                        else if (stricmp(annotationValue, "view") == 0 ||
                                stricmp(annotationValue, "devicelightspace") == 0)
                        {
                                fType = (cgfxAttrType)(fType + kAttrTypeViewDir - kAttrTypeFirstDir);
                        }
                        else if (stricmp(annotationValue, "projection") == 0)
                        {
                                fType = (cgfxAttrType)(fType + kAttrTypeProjectionDir - kAttrTypeFirstDir);
                        }
                        else if (stricmp(annotationValue, "screen") == 0)
                        {
                                fType = (cgfxAttrType)(fType + kAttrTypeScreenDir - kAttrTypeFirstDir);
                        }
                }
                else if (stricmp(annotationName, "object") == 0)
                {
                        fHint = kVectorHintNone;

                        if (stricmp(annotationValue, "dirlight") == 0)
                        {
                                fHint = kVectorHintDirLight;
                        }
                        else if (stricmp(annotationValue, "spotlight") == 0)
                        {
                                fHint = kVectorHintSpotLight;
                        }
                        else if (stricmp(annotationValue, "pointlight") == 0)
                        {
                                fHint = kVectorHintPointLight;
                        }
                        else if (stricmp(annotationValue, "camera") == 0 || stricmp(annotationValue, "eye") == 0)
                        {
                                fHint = kVectorHintEye;
                        }
                }
                cgAnnotation = cgGetNextAnnotation(cgAnnotation);
        }
        return;
}

// ========== cgfxAttrDef::attrsFromNode ==========
//
// This function simply returns the parses through the dynamic
// attributes on an effect and builds a list of cgfxAttrDef objects.
// The cgfxAttrDef objects in the list are incomplete but they are
// only used to determine which attributes on the object need to be
// created, destroyed, or left alone.  Ultimately, the cgfxAttrDefList
// that is constructed from the effect itself will be the one held by
// the node.
//
/* static */
cgfxRCPtr<cgfxAttrDefList> cgfxAttrDef::attrsFromNode(MObject& oNode)
{
        MStatus status;

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

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

        cgfxRCPtr<cgfxAttrDefList> list = pNode->attrDefList();

        // The list has not been initialized.  Create it and try again.
        //
        if (list.isNull())
        {
                buildAttrDefList(oNode);
                list = pNode->attrDefList();
        }

        return list;
}

// ========== cgfxAttrDef::buildAttrDefList ==========
//
// This routine reconstructs the attrDefList from stringArray value in
// the attributeList attribute.  The reconstructed list is incomplete
// but it is good enough to compare to the list generated by
// attrsFromEffect to see if the connections are still valid.
//
void cgfxAttrDef::buildAttrDefList(MObject& oNode)
{
        MStatus status;

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

    cgfxShaderNode* pNode = (cgfxShaderNode *) fnNode.userNode();
    M_CHECK( pNode && pNode->attrDefList().isNull() );

    cgfxRCPtr<cgfxAttrDefList> list(new cgfxAttrDefList);

    MStringArray saList;

    pNode->getAttributeList(saList);
    //         MStatus status;

    //         // Get the value of the attributeList attribute
    //         //
    //         MPlug    plug(oNode, cgfxShaderNode::sAttributeList);

    //         MObject saDataObject;

    //         status = plug.getValue(saDataObject);
    //         if (!status)
    //         {
    //             sprintf(errorMsg, "%s(%d): failed to get attributeList value: %s!",
    //                     __FILE__, __LINE__, status.errorString().asChar());
    //             throw errorMsg;
    //         }

    //         MFnStringArrayData fnSaData(saDataObject, &status);
    //         if (!status)
    //         {
    //             sprintf(errorMsg,
    //                     "%s(%d): failed to construct attributeList function set: %s!",
    //                     __FILE__, __LINE__, status.errorString().asChar());
    //             throw errorMsg;
    //         }

    //         fnSaData.copyTo(saList);

    // Ok, we succeeded, saList is now an array of "top level"
    // dynamic attribute names along with some minimal type
    // information.  Parse through it and reconstruct the
    // cgfxAttrDefList.
    //
    unsigned int i;
    for (i = 0; i < saList.length(); ++i)
    {
        MString item = saList[i];
        MStringArray  splitItem;
        MObject oAttr;

        item.split('\t', splitItem);

        cgfxAttrDef* attrDef = attrFromNode( fnNode,
                                             splitItem[0], 
                                             (cgfxAttrType)(splitItem[1].asInt()),
                                             splitItem[2],
                                             splitItem[3]);
        if ( attrDef )
        {
            list->add( attrDef );
        }
    }

    pNode->setAttrDefList(list);
}


/* static */
cgfxAttrDef*
cgfxAttrDef::attrFromNode( const MFnDependencyNode& fnNode,
                                           const MString&           sAttrName,
                                                   const cgfxAttrType       eAttrType,
                                                   const MString&           sDescription,
                                               const MString&           sSemantic)
{
        MStatus      status;
        cgfxAttrDef* attrDef = NULL;

        try
        {
                MObject obNode = fnNode.object();
                MObject obAttr = fnNode.attribute( sAttrName, &status );
                if ( !status )                 // if node doesn't have this attr
                        return NULL;               // skip it

                attrDef = new cgfxAttrDef(
            sAttrName, eAttrType, sDescription, sSemantic,
            obNode, obAttr
        );

        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                size_t ee = (size_t)e;
                MString sMsg = "(";
                sMsg += (int)ee;
                sMsg += ") cgfxShader node \"";
                sMsg += fnNode.name();
                sMsg += "\" has invalid attribute \"";
                sMsg += sAttrName;
                sMsg += "\" - ignored";
                MGlobal::displayWarning( sMsg );
                delete attrDef;
                attrDef = NULL; 
        }
        catch (...)
        {
                delete attrDef;
                M_CHECK( false );
        }

        return attrDef;
}                                      // cgfxAttrDef::attrFromNode


bool
cgfxAttrDef::createAttribute( const MObject& oNode, MDGModifier* mod, cgfxShaderNode* pNode)
{
        MFnDependencyNode fnNode( oNode );

        // Return if node already has an attribute with the specified name.
        // (Shader var name could conflict with a predefined static attr.)
        MObject obExistingAttr = fnNode.attribute( fName );
        if ( !obExistingAttr.isNull() )
        {
                return false;
        }

        try
        {
                MStatus status;
                MObject oAttr, oAttr2;

                MFnNumericAttribute     nAttr;
                MFnTypedAttribute       tAttr;
                MFnMatrixAttribute      mAttr;

                MObject oSrcNode, oDstNode;
                MFnDependencyNode fnFile;
                MObject oSrcAttr, oDstAttr;

                bool doConnection = false;

                switch (fType)
                {
                case kAttrTypeBool:
                        oAttr = nAttr.create( fName, fName, MFnNumericData::kBoolean,
                                0.0, &status );
                        M_CHECK( status );
                        nAttr.setKeyable( true );
                        nAttr.setAffectsAppearance( true );
                        break;

                case kAttrTypeInt:
                        oAttr = nAttr.create( fName, fName, MFnNumericData::kInt,
                                0.0, &status );
                        M_CHECK( status );
                        nAttr.setKeyable( true );
                        nAttr.setAffectsAppearance( true );
                        break;

                case kAttrTypeFloat:
                        oAttr = nAttr.create( fName, fName, MFnNumericData::kFloat,
                                0.0, &status );
                        M_CHECK( status );
                        nAttr.setKeyable( true );
                        nAttr.setAffectsAppearance( true );
                        break;

                case kAttrTypeString:
                        oAttr = tAttr.create(fName, fName, MFnData::kString,
                                MObject::kNullObj, &status );
                        tAttr.setAffectsAppearance( true );
                        M_CHECK( status );
                        break;

                case kAttrTypeVector2:
                case kAttrTypeVector3:
                case kAttrTypeVector4:
                case kAttrTypeColor3:
                case kAttrTypeColor4:

                case kAttrTypeObjectDir:
                case kAttrTypeWorldDir:
                case kAttrTypeViewDir:
                case kAttrTypeProjectionDir:
                case kAttrTypeScreenDir:

                case kAttrTypeObjectPos:
                case kAttrTypeWorldPos:
                case kAttrTypeViewPos:
                case kAttrTypeProjectionPos:
                case kAttrTypeScreenPos:
                        {
                                const char** suffixes = compoundAttrSuffixes( fType );
                                MString      sChild;
                                MObject      oaChildren[4];
                                M_CHECK( fSize <= 4 );
                                for ( int iChild = 0; iChild < fSize; ++iChild )
                                {
                                        const char* suffix = suffixes[ iChild ];
                                        sChild = fName + suffix;
                                        oaChildren[ iChild ] = nAttr.create( sChild,
                                                sChild,
                                                MFnNumericData::kFloat,
                                                0.0,
                                                &status );
                                        M_CHECK( status );
                                }

                                if ( fSize == 4 )
                                {
                                        oAttr2 = oaChildren[3];
                                        if ( fType == kAttrTypeColor3 ||
                                                fType == kAttrTypeColor4 ||
                                                fDescription.length() > 0 )
                                                nAttr.setKeyable( true );
                                }

                                oAttr = nAttr.create( fName,
                                        fName,
                                        oaChildren[0],
                                        oaChildren[1],
                                        oaChildren[2], 
                                        &status );
                                M_CHECK( status );

                                if ( fType == kAttrTypeColor3 ||
                                        fType == kAttrTypeColor4 )
                                {
                                        nAttr.setKeyable( true );
                                        nAttr.setUsedAsColor( true );
                                }
                                else if ( fDescription.length() > 0 )
                                        nAttr.setKeyable( true );
                                nAttr.setAffectsAppearance( true );

                                break;
                        }

                case kAttrTypeMatrix:
                        // Create a generic matrix
                        //
                        oAttr = mAttr.create(fName, fName,
                                MFnMatrixAttribute::kFloat, &status );
                        M_CHECK( status );
                        mAttr.setAffectsAppearance( true );
                        break;

                case kAttrTypeWorldMatrix:
                case kAttrTypeViewMatrix:
                case kAttrTypeProjectionMatrix:
                case kAttrTypeWorldViewMatrix:
                case kAttrTypeWorldViewProjectionMatrix:
                        // These matricies are handled internally and have no attribute.
                        //
                        break;

                case kAttrTypeColor1DTexture:
                case kAttrTypeColor2DTexture:
                case kAttrTypeColor3DTexture:
                case kAttrTypeColor2DRectTexture:
                case kAttrTypeNormalTexture:
                case kAttrTypeBumpTexture:
                case kAttrTypeCubeTexture:
                case kAttrTypeEnvTexture:
                case kAttrTypeNormalizationTexture:
                        if( pNode->getTexturesByName())
                        {
                                oAttr = tAttr.create(fName, fName, MFnData::kString,
                                        MObject::kNullObj, &status );
                                M_CHECK( status );
                                tAttr.setAffectsAppearance( true );
                        }
                        else
                        {
                                const char* suffix1 = "R";
                                const char* suffix2 = "G";
                                const char* suffix3 = "B";

                                MObject oChild1 = nAttr.create(fName + suffix1,
                                        fName + suffix1,
                                        MFnNumericData::kFloat,
                                        0.0, &status);
                                MObject oChild2 = nAttr.create(fName + suffix2,
                                        fName + suffix2,
                                        MFnNumericData::kFloat,
                                        0.0, &status);

                                MObject oChild3 = nAttr.create(fName + suffix3,
                                        fName + suffix3,
                                        MFnNumericData::kFloat,
                                        0.0, &status);

                                oAttr = nAttr.create( fName,
                                        fName,
                                        oChild1,
                                        oChild2,
                                        oChild3, 
                                        &status );
                                M_CHECK( status );

                                // Although it's not strictly necessary, set this attribute
                                // to be a color so the user can will at least get the
                                // texture assignment button in the AE if for some reason
                                // our AE template is missing
                                nAttr.setUsedAsColor( true );

                                nAttr.setAffectsAppearance( true );
                        }
                        break;
#ifdef _WIN32
                case kAttrTypeTime:
#endif
                case kAttrTypeOther:
                        break;
                default:
                        M_CHECK( false );
                }

                if (oAttr.isNull())
                {
                        // There is no attribute for this parameter
                        //
                        return false;
                }

                // Add the attribute to the node
                //
                status = mod->addAttribute( oNode, oAttr );
                M_CHECK( status );

                if (!oAttr2.isNull())
                {
                        status = mod->addAttribute( oNode, oAttr2 );
                        M_CHECK( status );
                }

                // Hold onto a copy of the attribute for easy access later.
                fAttr  = oAttr;
                fAttr2 = oAttr2;

                // If we need to connect this node to some other node, do so.
                //
                if (doConnection)
                {
                        status = mod->connect(oSrcNode, oSrcAttr, oDstNode, oDstAttr);
                        M_CHECK( status );
                }
                return true;                   // success
        }
        catch ( cgfxShaderCommon::InternalError* e )   
        {
                size_t ee = (size_t)e;
                fType = kAttrTypeUnknown;
                MString sMsg = "(";
                sMsg += (int)ee;
                sMsg += ") cgfxShader node \"";
                sMsg += fnNode.name();
                sMsg += "\": unable to add attribute \"";
                sMsg += fName;
                sMsg += "\"";
                MGlobal::displayWarning( sMsg );
                return false;                  // failure
        }
        catch (...)
        {
                M_CHECK( false );
        }

        return true;
}                                      // cgfxAttrDef::createAttribute


bool
cgfxAttrDef::destroyAttribute( MObject& oNode, MDGModifier* dgMod)
{
        MStatus status;

        // If this is a texture node, clear the value (which will destroy
        // any attached textures)
        if( fType >= kAttrTypeFirstTexture && fType <= kAttrTypeLastTexture)
                setTexture( oNode, "", dgMod);

        // New effect won't need this old attr anymore.  
        status = dgMod->removeAttribute( oNode, fAttr );

        // If there is a secondary attribute, remove that too.
        if ( !fAttr2.isNull() )
                status = dgMod->removeAttribute( oNode, fAttr2 );

        // Don't leave dangling references to deleted attributes.
        fAttr  = MObject::kNullObj;  
        fAttr2 = MObject::kNullObj;  

        return status == MStatus::kSuccess;
}                                      // cgfxAttrDef::destroyAttribute




// ========== cgfxAttrDef::updateNode ==========
//
// This routine takes a node and an effect and ensures that all those
// and only those attributes that should be on the node, are on the
// node.
//
// The output cgfxAttrDefList and its elements are newly 
// allocated.
//
/* static */
void
cgfxAttrDef::updateNode(
    const cgfxRCPtr<const cgfxEffect>&  effect,         // IN
    cgfxShaderNode*                     pNode,          // IN
    MDGModifier*                        dgMod,          // UPD
    cgfxRCPtr<cgfxAttrDefList>&         effectList,     // OUT
    MStringArray&                       attributeList ) // OUT
{
        MStatus status;

        effectList = cgfxRCPtr<cgfxAttrDefList>();

        try
        {
                MObject           oNode = pNode->thisMObject();
                MFnDependencyNode fnNode( oNode );
                MFnAttribute      fnAttr;

                effectList = effect->attrsFromEffect();  // caller will own this list
        cgfxRCPtr<cgfxAttrDefList> nodeList = attrsFromNode( oNode ); // oNode owns this one

                cgfxAttrDefList::iterator emIt;
                cgfxAttrDefList::iterator nmIt;

                cgfxAttrDef* adef;

                // Walk through the nodeList.  Delete each attribute that is not
                // also found in the effect list.
                //
                for (nmIt = nodeList->begin(); nmIt; ++nmIt)
                {                              // loop over nodeList
                        adef = (*nmIt);

                        // Skip if node doesn't have this attribute.
                        if ( adef->fAttr.isNull() )
                                continue;

                        // Look for a matching attribute in the effect
                        emIt = effectList->find( adef->fName );

                        // Drop Maya attribute from node if shader var
                        //   was declared in old effect, but not declared
                        //   in new effect, or data type is not the same.
                        if ( !emIt ||
                                (*emIt)->fType != adef->fType )
                        {
                                adef->destroyAttribute( oNode, dgMod);
                        }

                        // If this is a texture and it has a non-default
                        // value, we should switch to this mode of texture
                        // definition (names or nodes)
                        else if( emIt && 
                                (*emIt)->fType >= kAttrTypeFirstTexture &&
                                (*emIt)->fType <= kAttrTypeLastTexture)
                        {
                                // Get the attribute type of the existing attribute
                                // and ensure our node is setup to digest the correct
                                // type of textures
                                MFnTypedAttribute typedFn( adef->fAttr);
                                bool usesName = typedFn.attrType() == MFnData::kString;
                                pNode->setTexturesByName( usesName);

                                // Finally, if this texture uses fileTexture nodes then
                                // mark the value as "tweaked" to prevent the default value 
                                // code from trying to attach a default fileTexture node. 
                                // This is crucial to being able to load shaders back in. The
                                // Maya file will create our node using the following steps:
                                //      1) Create an empty cgfxShader node
                                //      2) Create all the dynamic attributes (like this texture)
                                //      3) Set the effect attribute (which calls this code)
                                //      4) Create DG connections to file texture nodes
                                // So, if we did setup a default file texture node, the load
                                // would be unable to connect the real file texture. 
                                //
                                if( !usesName)
                                        (*emIt)->fTweaked = true;
                        }


                }                              // loop over nodeList

                // Delete any unnecessary attributes before starting to add new ones
                // (in case we're deleting and re-creating a property with a different
                // type)
                // 
                dgMod->doIt();

                // Walk through the effectList.  Add each item that is not also
                // found in the node list.
                //
                for (emIt = effectList->begin(); emIt; ++emIt)
                {                              // loop over effectList 
                        adef = (*emIt);

                        // Note: nodeList::find will work with a null this pointer
                        // so nodeList->find() will work even if nodeList is NULL.
                        //
                        nmIt = nodeList->find( adef->fName );

                        // Double check that the attr still exists.  Get current value.
                        cgfxAttrDef* cdef = NULL;
                        if ( nmIt &&
                                !(*nmIt)->fAttr.isNull() )
                                cdef = attrFromNode( fnNode,
                                (*nmIt)->fName, 
                                (*nmIt)->fType,
                                (*nmIt)->fDescription,
                                (*nmIt)->fSemantic);

                        // Add new Maya attribute.
                        if ( !cdef )
                                adef->createAttribute( oNode, dgMod, pNode );

                        // Go on with existing attribute.
                        else
                        {                          // use existing attribute
                                // Copy the attribute handles to the new effect's cgfxAttrDef.
                                adef->fAttr  = (*nmIt)->fAttr;
                                adef->fAttr2 = (*nmIt)->fAttr2;

                                // Did we already notice that the user has set this attr?
                                if ( (*nmIt)->fTweaked )
                                        adef->fTweaked = true;

                                // If no old effect, then the current values were
                                //   loaded from the scene file, and should override 
                                //   the new effect's defaults if they are different.
                                else if ( pNode->effect().isNull() )
                                {
                                        if ( !adef->isInitialValueEqual( *cdef ) )
                                                adef->fTweaked = true;
                                }

                                // If current value is not the same as old effect's 
                                //   default, then user has adjusted it.  Current value
                                //   takes precedence over the new effect's default.
                                else if ( !(*nmIt)->isInitialValueEqual( *cdef ) )
                                        adef->fTweaked = true;

                                // User hasn't changed this value.  New effect's
                                // default takes precedence.  Since we are going to
                                // change the value, remember to change it back 
                                // to the old effect's default in case of undo.
                                // Among other things, this logic allows the UI shader
                                // description to update as different effects are chosen.
                                else
                                        (*nmIt)->fInitOnUndo = true;

                                delete cdef;
                        }                          // use existing attribute
                }                              // loop over effectList 

                // Now rebuild the attributeList attribute value.  This is an array
                // of strings of the format "attrName<TAB>type<TAB>Description<TAB>Semantic".
                //
                MString tmpStr;

                attributeList.clear();

                cgfxAttrDefList::iterator it(effectList);

                while (it)
                {
                        cgfxAttrDef* aDef = *it;

                        tmpStr = aDef->fName;
                        tmpStr += "\t";
                        tmpStr += (int)aDef->fType;
                        tmpStr += "\t";
                        tmpStr += aDef->fDescription;
                        tmpStr += "\t";
                        tmpStr += aDef->fSemantic;

                        // Drop trailing tabs.
                        const char* bp = tmpStr.asChar();
                        const char* ep;
                        for ( ep = bp + tmpStr.length(); bp < ep; --ep )
                                if ( ep[-1] != '\t' )
                                        break;

                        attributeList.append( MString( bp, (int)(ep - bp) ) );
                        ++it;
                }
        }
        catch ( cgfxShaderCommon::InternalError* )   
        {
                throw;
        }
        catch (...)
        {
                M_CHECK( false );
        }
}                                      // cgfxAttrDef::updateNode


// Return true if initial value of 'this' is same as 'that'.
bool
cgfxAttrDef::isInitialValueEqual( const cgfxAttrDef& that ) const
{
        if ( fStringDef != that.fStringDef )
                return false;

        const double* thisNumericDef = fNumericDef;
        const double* thatNumericDef = that.fNumericDef;

        if ( thisNumericDef == thatNumericDef ) 
                return true;

        // Make sure we don't proceed to test default colour values for
        // texture attributes as the colour itself is meaningless!
        //
        if( fType == that.fType && fType >= kAttrTypeFirstTexture && fType <= kAttrTypeLastTexture)
                return true;

        if ( !thisNumericDef )
        {
                thisNumericDef = thatNumericDef;
                thatNumericDef = fNumericDef;
        }

        if ( !thatNumericDef )
        {
                if ( fType == kAttrTypeMatrix )
                {
                        thatNumericDef = &MMatrix::identity.matrix[0][0];
                        M_CHECK( fSize == 16 && that.fSize == 16 );
                }
                else
                {
                        static const double d0[4] = {0.0, 0.0, 0.0, 0.0};
                        thatNumericDef = d0;
                        M_CHECK( fSize <= sizeof(d0)/sizeof(d0[0]) );
                        if ( fSize != that.fSize )
                                MGlobal::displayWarning( "CgFX attribute size mismatch" );
                }
        }

        double eps = 0.0001;
        int i;
        for ( i = 0; i < fSize; ++i )
                if ( thisNumericDef[ i ] + eps < thatNumericDef[ i ] ||
                        thatNumericDef[ i ] + eps < thisNumericDef[ i ] )
                        return false;

        return true;
}                                      // cgfxAttrDef::isInitialValueEqual


// Copy initial value from given attribute.
void
cgfxAttrDef::setInitialValue( const cgfxAttrDef& from )
{
        if ( from.fNumericDef )
        {
                M_CHECK( fSize == from.fSize );
                if ( !fNumericDef )
                        fNumericDef = new double[ fSize ];
                memcpy( fNumericDef, from.fNumericDef, fSize * sizeof( *fNumericDef ) );
        }
        else
        {
                delete fNumericDef;
                fStringDef = from.fStringDef;
        }
}                                      // cgfxAttrDef::setInitialValue


// Set attribute flag
void cgfxAttrDef::setAttributeFlags()
{
        MFnAttribute attribute;
        if(!attribute.setObject(fAttr))
                return ;

        switch (fType)
        {
        case kAttrTypeColor3:
        case kAttrTypeColor4:
                attribute.setKeyable( true );
                attribute.setUsedAsColor( true );
                attribute.setAffectsAppearance( true );
                break;

        case kAttrTypeBool:
        case kAttrTypeInt:
        case kAttrTypeFloat:
                attribute.setKeyable( true );
                attribute.setAffectsAppearance( true );
                break;
        
        case kAttrTypeVector2:
        case kAttrTypeVector3:
        case kAttrTypeVector4:
        case kAttrTypeObjectDir:
        case kAttrTypeWorldDir:
        case kAttrTypeViewDir:
        case kAttrTypeProjectionDir:
        case kAttrTypeScreenDir:
        case kAttrTypeObjectPos:
        case kAttrTypeWorldPos:
        case kAttrTypeViewPos:
        case kAttrTypeProjectionPos:
        case kAttrTypeScreenPos:
                if(     fDescription.length() > 0)
                        attribute.setKeyable( true );
                attribute.setAffectsAppearance( true );
                break;

        case kAttrTypeString:
        case kAttrTypeMatrix: // Create a generic matrix
                attribute.setAffectsAppearance( true );
                break;

        case kAttrTypeWorldMatrix:
        case kAttrTypeViewMatrix:
        case kAttrTypeProjectionMatrix:
        case kAttrTypeWorldViewMatrix:
        case kAttrTypeWorldViewProjectionMatrix:
                // These matricies are handled internally and have no attribute.
                //
                break;

        case kAttrTypeColor1DTexture:
        case kAttrTypeColor2DTexture:
        case kAttrTypeColor3DTexture:
        case kAttrTypeColor2DRectTexture:
        case kAttrTypeNormalTexture:
        case kAttrTypeBumpTexture:
        case kAttrTypeCubeTexture:
        case kAttrTypeEnvTexture:
        case kAttrTypeNormalizationTexture:
                /*if(!getTexturesByName())
                        // Although it's not strictly necessary, set this attribute
                        // to be a color so the user can will at least get the
                        // texture assignment button in the AE if for some reason
                        // our AE template is missing
                        attribute.setUsedAsColor( true );*/
                attribute.setAffectsAppearance( true );
                break;

#ifdef _WIN32
        case kAttrTypeTime:
#endif
        case kAttrTypeOther:
                break;
        default:
                M_CHECK( false );
        }
}

// Set Maya attributes to their initial values.
/* static */
void
cgfxAttrDef::initializeAttributes(
    MObject&                            oNode,
    const cgfxRCPtr<cgfxAttrDefList>&   list,
    bool                                bUndoing,
    MDGModifier*                        dgMod)
{
        MStatus             status;
        MFnMatrixAttribute  fnMatrix;
        MFnNumericAttribute fnNumeric;
        MFnTypedAttribute   fnTyped;
        for ( cgfxAttrDefList::iterator it( list ); it; ++it )
        {                                  // loop over cgfxAttrDefList
                cgfxAttrDef* aDef = (*it);

                if ( aDef->fAttr.isNull() )    // if no Maya attr
                        continue;                  // try next

                bool bSetValue = bUndoing ? aDef->fInitOnUndo
                        : !aDef->fTweaked;

                try
                {
                        // Boolean
                        if ( aDef->fType == kAttrTypeBool )
                        {
                                if ( bSetValue )
                                        aDef->setValue( oNode, aDef->fNumericDef && aDef->fNumericDef[0] );
                        }

                        // Texture node: must be check before both numeric (as a
                        // texture could be a float3 colour) and string (as it
                        // could also be a string)
                        else if( aDef->fType >= kAttrTypeFirstTexture && 
                                aDef->fType <= kAttrTypeLastTexture)
                        {
                                if ( bSetValue )
                                        aDef->setTexture( oNode, aDef->fStringDef, dgMod);
                        }

                        // Numeric
                        else if ( fnNumeric.setObject( aDef->fAttr ) ) 
                        {                          // numeric attr

                                // Constants for removing old bounds...
                                double vMin = -FLT_MAX;
                                double vMax = FLT_MAX;
                                if ( aDef->fType == kAttrTypeInt )
                                {
                                        vMin = INT_MIN;
                                        vMax = INT_MAX;
                                }

                                // Set or remove bounds.

                                switch ( aDef->fSize )
                                {                      // switch to set/remove bounds
                                case 1:
                                        if ( aDef->fNumericMin )
                                                fnNumeric.setMin( aDef->fNumericMin[0] );
                                        else if ( fnNumeric.hasMin() )
                                                fnNumeric.setMin( vMin );

                                        if ( aDef->fNumericMax )
                                                fnNumeric.setMax( aDef->fNumericMax[0] );
                                        else if ( fnNumeric.hasMax() )
                                                fnNumeric.setMax( vMax );

                                        if ( aDef->fNumericSoftMin )
                                                fnNumeric.setSoftMin( aDef->fNumericSoftMin[0] );
                                        else if ( fnNumeric.hasSoftMin() )
                                                fnNumeric.setSoftMin( vMin );

                                        if ( aDef->fNumericSoftMax )
                                                fnNumeric.setSoftMax( aDef->fNumericSoftMax[0] );
                                        else if ( fnNumeric.hasSoftMax() )
                                                fnNumeric.setSoftMax( vMax );
                                        break;

                                case 2:
                                        if ( aDef->fNumericMin )
                                                fnNumeric.setMin( aDef->fNumericMin[0], 
                                                aDef->fNumericMin[1] );
                                        else if ( fnNumeric.hasMin() )
                                                fnNumeric.setMin( vMin, vMin );

                                        if ( aDef->fNumericMax )
                                                fnNumeric.setMax( aDef->fNumericMax[0], 
                                                aDef->fNumericMax[1] );
                                        else if ( fnNumeric.hasMax() )
                                                fnNumeric.setMax( vMax, vMax );
                                        break;

                                case 3:
                                case 4:
                                        if ( aDef->fNumericMin )
                                                fnNumeric.setMin( aDef->fNumericMin[0], 
                                                aDef->fNumericMin[1],
                                                aDef->fNumericMin[2] );
                                        else if ( fnNumeric.hasMin() )
                                                fnNumeric.setMin( vMin, vMin, vMin );

                                        if ( aDef->fNumericMax )
                                                fnNumeric.setMax( aDef->fNumericMax[0], 
                                                aDef->fNumericMax[1],
                                                aDef->fNumericMax[2] );
                                        else if ( fnNumeric.hasMax() )
                                                fnNumeric.setMax( vMax, vMax, vMax );
                                        break;

                                default:
                                        M_CHECK( false );
                                }                      // switch to set/remove bounds

                                // Set initial value.
                                //   Use 0 if no initial value specified in .fx file.
                                if ( bSetValue )
                                {                      // set numeric initial value
                                        static const double d0[4] = {0.0, 0.0, 0.0, 0.0};
                                        const double* pNumericDef = aDef->fNumericDef ? aDef->fNumericDef
                                                : d0;
                                        switch ( aDef->fSize )
                                        {                  
                                        case 1:
                                                if ( aDef->fType == kAttrTypeInt )
                                                        aDef->setValue( oNode, (int)pNumericDef[0] );
                                                else
                                                        aDef->setValue( oNode, (float)pNumericDef[0] );
                                                break;

                                        case 2:
                                                aDef->setValue( oNode,
                                                        (float)pNumericDef[0],
                                                        (float)pNumericDef[1] );
                                                break;

                                        case 3:
                                                aDef->setValue( oNode,
                                                        (float)pNumericDef[0],
                                                        (float)pNumericDef[1],
                                                        (float)pNumericDef[2] );
                                                break;

                                        case 4:
                                                status = fnNumeric.setObject( aDef->fAttr2 );
                                                M_CHECK( status );

                                                if ( aDef->fNumericMin )
                                                        fnNumeric.setMin( aDef->fNumericMin[3] );
                                                else if ( fnNumeric.hasMin() )
                                                        fnNumeric.setMin( vMin );

                                                if ( aDef->fNumericMax )
                                                        fnNumeric.setMax( aDef->fNumericMax[3] );
                                                else if ( fnNumeric.hasMax() )
                                                        fnNumeric.setMax( vMax );

                                                aDef->setValue( oNode,
                                                        (float)pNumericDef[0],
                                                        (float)pNumericDef[1],
                                                        (float)pNumericDef[2],
                                                        (float)pNumericDef[3] );
                                                break;

                                        default:
                                                M_CHECK( false );
                                        }                  // switch ( aDef->fSize )
                                }                      // set numeric initial value
                        }                          // numeric attr

                        // String
                        else if ( fnTyped.setObject( aDef->fAttr ) &&
                                fnTyped.attrType() == MFnData::kString )
                        {
                                if ( bSetValue )
                                        aDef->setValue( oNode, aDef->fStringDef );
                        }

                        // Matrix
                        else if ( fnMatrix.setObject( aDef->fAttr ) )
                        {
                                if ( !bSetValue )
                                {}
                                else if ( aDef->fNumericDef )
                                {
                                        MMatrix m;
                                        double* p = &m.matrix[0][0];
                                        for ( int k = 0; k < 16; ++k )
                                                p[ k ] = aDef->fNumericDef[ k ];
                                        aDef->setValue( oNode, m );
                                }
                                else
                                        aDef->setValue( oNode, MMatrix::identity );
                        }
                }
                catch ( cgfxShaderCommon::InternalError* e )   
                {
                        size_t ee = (size_t)e;
                        MFnDependencyNode fnNode( oNode );
                        MString sMsg = "(";
                        sMsg += (int)ee;
                        sMsg += ") cgfxShader node \"";
                        sMsg += fnNode.name();
                        sMsg += "\": unable to initialize attribute \"";
                        sMsg += aDef->fName;
                        sMsg += "\"";
                        MGlobal::displayWarning( sMsg );
                }
        }                                  // loop over cgfxAttrDefList
}                                      // cgfxAttrDef::initializeAttributes



// Clear all Maya attribute references in a cgfxAttrDefList.
//   This should be called whenever the list is detached from 
//   the cgfxShader node, to avert an eventual exception in 
//   MObject::~MObject() in case the referenced Maya attribute 
//   happens to be deleted while the cgfxAttrDefList is in
//   suspense on Maya's undo queue.
//
/* static */
void cgfxAttrDef::purgeMObjectCache(const cgfxRCPtr<cgfxAttrDefList>& list)
{                                       
        cgfxAttrDefList::iterator it( list );
        for ( ; it; ++it )
        {
                cgfxAttrDef* aDef = (*it);
                aDef->fAttr  = MObject::kNullObj;
                aDef->fAttr2 = MObject::kNullObj;
        }
}                                      // cgfxAttrDef::purgeMObjectCache


// Refresh Maya attribute references in a cgfxAttrDefList.
//   This should be called whenever a saved list is re-attached
//   to the cgfxShader node in the course of undo or redo.
//
/* static */
void cgfxAttrDef::validateMObjectCache(
    const MObject&                      obCgfxShader, 
    const cgfxRCPtr<cgfxAttrDefList>&   list)
{                                       
        MStatus status;
        MString sName2;
        MFnDependencyNode fnNode( obCgfxShader, &status );
        cgfxAttrDefList::iterator it( list );
        for ( ; it; ++it )
        {
                cgfxAttrDef* aDef = (*it);
                aDef->fAttr = fnNode.attribute( aDef->fName, &status );

                // 4-element vectors use an extra attribute for the 4th element.
                const char* suffix = aDef->getExtraAttrSuffix();
                if ( suffix )
                        aDef->fAttr2 = fnNode.attribute( aDef->fName + suffix, &status );
        }
}                                      // cgfxAttrDef::validateMObjectCache


// Return suffix for Color4/Vector4 extra attribute, or NULL.
const char*
cgfxAttrDef::getExtraAttrSuffix() const
{
        if ( fSize == 4 )
                return compoundAttrSuffixes( fType )[ 3 ];
        return NULL;
}                                      // cgfxAttrDef::getExtraAttrSuffix


// Get a string representation of a cgfxAttrType
//
/* static */
const char* cgfxAttrDef::typeName( cgfxAttrType type )
{
#define CASE(name) case kAttrType##name: return #name

        switch (type)
        {
        default:    // Fall through into case unknown
                CASE(Unknown);
                CASE(Bool);
                CASE(Int);
                CASE(Float);
                CASE(String);
                CASE(Vector2);
                CASE(Vector3);
                CASE(Vector4);
                CASE(ObjectDir);
                CASE(WorldDir);
                CASE(ViewDir);
                CASE(ProjectionDir);
                CASE(ScreenDir);
                CASE(ObjectPos);
                CASE(WorldPos);
                CASE(ViewPos);
                CASE(ProjectionPos);
                CASE(ScreenPos);
                CASE(Color3);
                CASE(Color4);
                CASE(Matrix);
                CASE(WorldMatrix);
                CASE(ViewMatrix);
                CASE(ProjectionMatrix);
                CASE(WorldViewMatrix);
                CASE(WorldViewProjectionMatrix);
                CASE(Color1DTexture);
                CASE(Color2DTexture);
                CASE(Color3DTexture);
                CASE(Color2DRectTexture);
                CASE(NormalTexture);
                CASE(BumpTexture);
                CASE(CubeTexture);
                CASE(EnvTexture);
                CASE(NormalizationTexture);
#ifdef _WIN32
                CASE(Time);
#endif
                CASE(Other);
        }
}


/* static */
const char**
cgfxAttrDef::compoundAttrSuffixes( cgfxAttrType eAttrType )
{
        static const char* simple[] = { NULL, NULL, NULL, NULL,    NULL };
        static const char* vector[] = { "X",  "Y",  "Z",  "W",     NULL };
        static const char* color[]  = { "R",  "G",  "B",  "Alpha", NULL };

        const char** p;
        switch ( eAttrType )
        {
        case kAttrTypeVector2:
        case kAttrTypeVector3:
        case kAttrTypeVector4:
        case kAttrTypeObjectDir:
        case kAttrTypeWorldDir:
        case kAttrTypeViewDir:
        case kAttrTypeProjectionDir:
        case kAttrTypeScreenDir:
        case kAttrTypeObjectPos:
        case kAttrTypeWorldPos:
        case kAttrTypeViewPos:
        case kAttrTypeProjectionPos:
        case kAttrTypeScreenPos:
                p = vector;
                break;
        case kAttrTypeColor3:
        case kAttrTypeColor4:
                p = color;
                break;
        default:
                p = simple;
                break;
        }
        return p;
}                                      // cgfxAttrDef::compoundAttrSuffixes



// Methods to get attribute values
//
void
cgfxAttrDef::getValue( MObject& oNode, bool& value ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.getValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::getValue( MObject& oNode, int& value ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.getValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::getValue( MObject& oNode, float& value ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.getValue(value);
        if( fUnits != MDistance::kInvalid)
        {
                value = (float)MDistance( value, fUnits).as( MDistance::internalUnit());
        }
        M_CHECK( status );
}

void
cgfxAttrDef::getValue( MObject& oNode, MString& value ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.getValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::getValue( MObject& oNode, float& v1, float& v2 ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        MObject oData;
        status = plug.getValue(oData);
        M_CHECK( status );

        MFnNumericData fnData(oData, &status);
        M_CHECK( status );

        status = fnData.getData(v1, v2);
        M_CHECK( status );

        if( fUnits != MDistance::kInvalid)
        {
                v1 = (float)MDistance( v1, fUnits).as( MDistance::internalUnit());
                v2 = (float)MDistance( v2, fUnits).as( MDistance::internalUnit());
        }
}

void
cgfxAttrDef::getValue( MObject& oNode,
                                                                                        float& v1, float& v2, float& v3 ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        MObject oData;
        status = plug.getValue(oData);
        M_CHECK( status );

        MFnNumericData fnData(oData, &status);
        M_CHECK( status );

        status = fnData.getData(v1, v2, v3);
        M_CHECK( status );

        if( fUnits != MDistance::kInvalid)
        {
                v1 = (float)MDistance( v1, fUnits).as( MDistance::internalUnit());
                v2 = (float)MDistance( v2, fUnits).as( MDistance::internalUnit());
                v3 = (float)MDistance( v3, fUnits).as( MDistance::internalUnit());
        }
}

void
cgfxAttrDef::getValue( MObject& oNode,
                                                                                        float& v1, float& v2, float& v3, float& v4 ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        MPlug plug2(oNode, fAttr2);

        MObject oData;
        status = plug.getValue(oData);
        M_CHECK( status );

        MFnNumericData fnData(oData, &status);
        M_CHECK( status );

        status = fnData.getData(v1, v2, v3);
        M_CHECK( status );

        // Get the 4th value from the extra attribute.
        //
        status = plug2.getValue(v4);
        M_CHECK( status );

        if( fUnits != MDistance::kInvalid)
        {
                v1 = (float)MDistance( v1, fUnits).as( MDistance::internalUnit());
                v2 = (float)MDistance( v2, fUnits).as( MDistance::internalUnit());
                v3 = (float)MDistance( v3, fUnits).as( MDistance::internalUnit());
                v4 = (float)MDistance( v4, fUnits).as( MDistance::internalUnit());
        }
}

void
cgfxAttrDef::getValue( MObject& oNode, MMatrix& value ) const
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        MObject oData;
        status = plug.getValue(oData);
        M_CHECK( status );

        MFnMatrixData fnData(oData, &status);
        M_CHECK( status );

        value = fnData.matrix(&status);
        M_CHECK( status );
}

void
cgfxAttrDef::getValue( MObject& oNode, MImage& value ) const
{
        MStatus status = MS::kFailure;
        MPlug plug(oNode, fAttr);

        if (fType >= kAttrTypeFirstTexture &&
                fType <= kAttrTypeLastTexture)
        {
                MPlugArray plugArray;
                plug.connectedTo(plugArray, true, false, &status);
                M_CHECK( status );

                if (plugArray.length() != 1)
                        M_CHECK( status );

                MPlug srcPlug = plugArray[0];
                MObject oSrcNode = srcPlug.node();

                // OutputDebugStrings("Source texture object = ", oSrcNode.apiTypeStr());

                value.release();
                status = value.readFromTextureNode(oSrcNode);
                M_CHECK( status );
        }
        M_CHECK( status );
}


// Get the source of an attribute value
//
void
cgfxAttrDef::getSource( MObject& oNode, MPlug& src) const
{
        MStatus status = MS::kFailure;
        MPlug plug(oNode, fAttr);

        MPlugArray plugArray;
        plug.connectedTo(plugArray, true, false, &status);
        M_CHECK( status && plugArray.length() <= 1);

        if (plugArray.length() == 1)
                src = plugArray[0];
}


// Methods to set attribute values
//
void
cgfxAttrDef::setValue( MObject& oNode, bool value )
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.setValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, int value )
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.setValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, float value )
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        
        status = plug.setValue(value);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, const MString& value )
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        status = plug.setValue((MString &)value);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, float v1, float v2 )
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        MFnNumericData fnData;
        MObject oData = fnData.create(MFnNumericData::k2Float, &status);
        M_CHECK( status );

        fnData.setData(v1, v2);
        status = plug.setValue(oData);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, float v1, float v2, float v3 )
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        MFnNumericData fnData;
        MObject oData = fnData.create(MFnNumericData::k3Float, &status);
        M_CHECK( status );

        fnData.setData(v1, v2, v3);
        status = plug.setValue(oData);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, float v1, float v2, float v3, float v4 )
{
        MStatus status;
        MPlug plug(oNode, fAttr);
        MPlug plug2(oNode, fAttr2);

        MFnNumericData fnData;
        MObject oData = fnData.create(MFnNumericData::k3Float, &status);
        M_CHECK( status );
        
        fnData.setData(v1, v2, v3);
        status = plug.setValue(oData);
        M_CHECK( status );

        status = plug2.setValue(v4);
        M_CHECK( status );
}

void
cgfxAttrDef::setValue( MObject& oNode, const MMatrix& v )
{
        MStatus       status;
        MFnMatrixData fnData;
        MObject       oData = fnData.create( v, &status );
        M_CHECK( status );

        MPlug plug( oNode, fAttr );
        status = plug.setValue( oData );
        M_CHECK( status );
}

// Utility to check if a node is used by any nodes other than us
//
bool isUsedElsewhere( MObject node, MObject user)
{
        for( MItDependencyGraph iter( node); !iter.isDone(); iter.next())
        {
                // If there is a downstream connection to something other than our shader ...
                //
                if( iter.thisNode() != node)
                {
                        if( iter.thisNode() != user)
                        {
                                // And that connection uses anything other than the message attribute
                                // of the texture (which is used to connect the texture to the 
                                // global texture list)
                                //
                                MPlugArray src;
                                iter.thisPlug().connectedTo( src, true, false);
                                if( src.length() == 1 && src[ 0].partialName() != "msg")
                                {
                                        // Finally, check this isn't just the swatch renderer taking
                                        // a quick look at this node
                                        //
                                        MFnDependencyNode dgFn( iter.thisNode());
                                        if( dgFn.name() != "swatchShadingGroup")
                                        {
                                                // Then we're not the only user of this node!
                                                //
                                                //cout<<"Not removing node due to connection<<src[0].name().asChar()<<" to "<<iter.thisPlug().name().asChar()<<endl;
                                                return true;
                                        }
                                }
                        }

                        // If this downstream connection is to another shader, or a
                        // message connection, don't follow the connection any further
                        //
                        iter.prune();
                }
        }
        return false;
}


void
cgfxAttrDef::setTexture( MObject& oNode, const MString& value, MDGModifier*     dgMod)
{
        MStatus status;
        MPlug plug(oNode, fAttr);

        // Is this a node or name based texture?
        //
        MFnAttribute attrFn( fAttr);
        if( attrFn.isUsedAsColor() )
        {
                // Node based texture.
                // Remove any existing texture
                //
                if( plug.isConnected())
                {
                        MPlugArray src;
                        plug.connectedTo( src, true, false, &status);
                        M_CHECK( status );
                        if( src.length() > 0)
                        {
                                MObject textureNode = src[ 0].node();

                                // If no other nodes use this texture, we can remove it to 
                                // avoid cluttering up the scene with unused texture nodes
                                //
                                if( !isUsedElsewhere( textureNode, oNode))
                                {
                                        // We are the only user of this texture node so we
                                        // can delete it. Before we do that though, are
                                        // we the only user of the placement node too?
                                        //
                                        MFnDependencyNode textureFn( textureNode);
                                        MPlug uvPlug = textureFn.findPlug( "uv", &status);
                                        if( status == MS::kSuccess)
                                        {
                                                MPlugArray placementNode;
                                                uvPlug.connectedTo( placementNode, true, false, &status);
                                                M_CHECK( status );

                                                // If we are the only user of the placement node, delete 
                                                // it as well
                                                //
                                                if( placementNode.length() > 0 &&
                                                        !isUsedElsewhere( placementNode[ 0].node(), textureNode))
                                                        M_CHECK( dgMod->deleteNode( placementNode[ 0].node()) );
                                        }

                                        // Delete the texture node
                                        //
                                        M_CHECK( dgMod->deleteNode( textureNode) );
                                }
                                else
                                {
                                        // We're not deleting the texture, so just disconnect it
                                        //
                                        M_CHECK( dgMod->disconnect( src[ 0], plug) );
                                }
                        }
                }

                // Do we have a (default) value to set?
                //
                if( value.length() > 0)
                {
                        // Resolve the texture value as either an absolute or
                        // project relative path. Even though we re-resolve paths
                        // when loading textures ourselves, if we want the Maya
                        // texture swatch to display, Maya needs to be able to
                        // find the texture as well.
                        //
                        MString relativePath = cgfxFindFile( value, true );

                        // If we didn't find it, just leave the original path (even
                        // though it wont work)
                        //
                        if( relativePath.length() == 0) relativePath = value;

                        // Create a new file texture and placement node
                        // Use the MEL commands (as opposed to dgMod.createNode) as these
                        // correctly hook up the rendering message connections so our 
                        // nodes show up in the hypershade etc.
                        //
                        MObject textureNode, placementNode;
                        MSelectionList originalSelection, newlyCreatedNode;
                        MGlobal::getActiveSelectionList( originalSelection);                    
                        dgMod->commandToExecute( "shadingNode -asTexture file" );
                        // the next operation getActiveSelectionList needs the node indeed created, so force doIt.
                        dgMod->doIt();
                        MGlobal::getActiveSelectionList( newlyCreatedNode);
                        M_CHECK( newlyCreatedNode.length() > 0 && newlyCreatedNode.getDependNode( 0, textureNode));                     
                        dgMod->commandToExecute( "shadingNode -asUtility place2dTexture" );
                        // the next operation getActiveSelectionList needs the node indeed created, so force doIt.
                        dgMod->doIt();
                        MGlobal::getActiveSelectionList( newlyCreatedNode);
                        M_CHECK( newlyCreatedNode.length() > 0 && newlyCreatedNode.getDependNode( 0, placementNode));
                        MGlobal::setActiveSelectionList( originalSelection);
                        MFnDependencyNode fileTextureFn( textureNode, &status);
                        M_CHECK( status );
                        MFnDependencyNode placementFn( placementNode, &status);
                        M_CHECK( status );

                        // Connect the placement node to the file texture node
                        //
                        M_CHECK( dgMod->connect( placementFn.findPlug( "coverage"), fileTextureFn.findPlug( "coverage")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "translateFrame"), fileTextureFn.findPlug( "translateFrame")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "rotateFrame"), fileTextureFn.findPlug( "rotateFrame")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "mirrorU"), fileTextureFn.findPlug( "mirrorU")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "mirrorV"), fileTextureFn.findPlug( "mirrorV")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "stagger"), fileTextureFn.findPlug( "stagger")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "wrapU"), fileTextureFn.findPlug( "wrapU")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "wrapV"), fileTextureFn.findPlug( "wrapV")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "repeatUV"), fileTextureFn.findPlug( "repeatUV")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "offset"), fileTextureFn.findPlug( "offset")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "rotateUV"), fileTextureFn.findPlug( "rotateUV")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "noiseUV"), fileTextureFn.findPlug( "noiseUV")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "vertexUvOne"), fileTextureFn.findPlug( "vertexUvOne")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "vertexUvTwo"), fileTextureFn.findPlug( "vertexUvTwo")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "vertexUvThree"), fileTextureFn.findPlug( "vertexUvThree")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "vertexCameraOne"), fileTextureFn.findPlug( "vertexCameraOne")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "outUV"), fileTextureFn.findPlug( "uv")) );
                        M_CHECK( dgMod->connect( placementFn.findPlug( "outUvFilterSize"), fileTextureFn.findPlug( "uvFilterSize")) );

                        // Connect our file texture node to our shader attribute, then set the texture
                        //
                        M_CHECK( dgMod->connect( fileTextureFn.findPlug( "outColor"), plug) );
                        status = fileTextureFn.findPlug( "fileTextureName").setValue( relativePath);
                        M_CHECK( status );
                }

                M_CHECK( dgMod->doIt() );
        }
        else
        {
                // Simple String attribute - but do a safety check to be sure
                //
                MFnTypedAttribute fnTyped;
                if( fnTyped.setObject( fAttr ) &&
                        fnTyped.attrType() == MFnData::kString )
                {
                        status = plug.setValue((MString &)value);
                        M_CHECK( status );
                }
        }
}

void cgfxAttrDef::setUnitsToInternal( CGparameter& cgParameter ) 
{
        
        // If the units are converted to internal, return
        if (fIsConvertedToInternal) return;

        CGannotation cgAnnotation = cgGetFirstParameterAnnotation(cgParameter);
        while (cgAnnotation)
        {
                const char* annotationName              = cgGetAnnotationName(cgAnnotation);
                const char* annotationValue             = cgGetStringAnnotationValue(cgAnnotation);
                if( stricmp( annotationName, "units" ) == 0)
                {
                        MString unit(&fSymbol);
                        unit += annotationValue;
                        // Notice: _XXX is a internal unit
                        cgSetStringAnnotation(cgAnnotation, unit.asChar());
                        // Make sure if the bind is called more than one time, no need to set to internal again
                        fIsConvertedToInternal = true;
                        return;
                }
                cgAnnotation = cgGetNextAnnotation(cgAnnotation);
        }
}
//--------------------------------------------------------------------//
//                          cgfxAttrDefList                           //
//--------------------------------------------------------------------//

cgfxAttrDefList::iterator
cgfxAttrDefList::findInsensitive( const MString& name )
{
        const char* pName = name.asChar();
        unsigned    lName = name.length();
        iterator    it( *this );
        for ( ; it; ++it )
                if ( lName == (*it)->fName.length() &&
                        0 == stricmp( pName, (*it)->fName.asChar() ) )
                        break;
        return it;
};                                     // cgfxAttrDefList::findInsensitive

void cgfxAttrDefList::release()
{
        --refcount;
        if (refcount <= 0)
        {
        M_CHECK( refcount == 0 );
                delete this;
        }
};

void cgfxAttrDefList::releaseTextures()
{
    iterator it(*this);
    while (it)
    {
        (*it)->release();
        ++it;
    }
}

void cgfxAttrDefList::dump(const char* name)
{
    fprintf(stderr, "Dumping cgfxAttrDefList %s : \n", name);
  
    for (cgfxAttrDefList::iterator it = begin(); it; ++it) {
        cgfxAttrDef* aDef = (*it);
        fprintf(
            stderr,
            "   name=%s, type=%s, size=%d, attr=%s, hint=%d, attr2=%s, def=%s, desc=%s, semantic=%s, CGParameter=0x%p\n",
            aDef->fName.asChar(),
            cgfxAttrDef::typeName(aDef->fType),
            aDef->fSize,
            aDef->fAttr.apiTypeStr(),
            aDef->fHint,
            aDef->fAttr2.apiTypeStr(),
            aDef->fStringDef.asChar(),
            aDef->fDescription.asChar(),
            aDef->fSemantic.asChar(),
            aDef->fParameterHandle
        );
    }
}