VOP/VOP_Node.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        VOP Library (C++)
 *
 * COMMENTS:    The base class for all VOP operators
 *
 */

#ifndef __VOP_Node_h__
#define __VOP_Node_h__

#include <set>
#include <map>

#include "VOP_API.h"
#include "VOP_Error.h"
#include "VOP_Language.h"
#include "VOP_TypeInfo.h"
#include "VOP_OperatorInfo.h"
#include "VOP_OutputInfoManager.h"
#include <OP/OP_Network.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_PtrArray.h>
#include <vector>

#define FLAG_OPT_LOW            'L'
#define FLAG_OPT_MEDIUM         'M'
#define FLAG_OPT_HIGH           'H'
#define VOP_DEBUG_FLAG          'D'

// The name of the parameter that contains the ordering of the
// VOPNET Parameters.
#define VOP_PARMORDER_NAME              "parmorder"
#define VOP_GLOBAL_NODE_NAME            "global"
#define VOP_ILLUM_NODE_NAME             "illuminance"
#define VOP_PARM_NODE_NAME              "parameter"
#define VOP_CONST_NODE_NAME             "constant"
#define VOP_PARMRAMP_NODE_NAME          "rampparm"
#define VOP_INLINE_CODE_NODE_NAME       "inline"
#define VOP_COLLECT_NODE_NAME           "collect"
#define VOP_RSL_PREFIX                  "rsl_"
#define VOP_VARIABLE_INOUT_MAX          2048

class VOP_Node;
class VOP_GlobalVarData;
class VOP_ParmGenerator;
class VOP_AutoConvert;
class VOP_CodeVarMapperContext;
class VOP_CodeParmList;

extern "C" {
    SYS_VISIBILITY_EXPORT extern void       newVopOperator(OP_OperatorTable *table);
};

typedef UT_PtrArray<VOP_Node *>          VOP_NodeList;
typedef UT_PtrArray<VOP_GlobalVarData *> VOP_GlobalVarList;
typedef UT_PtrArray<VOP_ParmGenerator *> VOP_ParmGeneratorList;

struct VOP_AutoConvertInfo
{
    // A pointer to the autoconvert node and a value for the input index.
    VOP_AutoConvert* myACNode;
    int myIndex;
};
typedef std::vector < VOP_AutoConvertInfo > TAutoConvertInfos;

typedef std::set < int > TIntSet;
struct VOP_MergeNodeInfo
{
    VOP_Node* myNode;
    TIntSet myInputIndices;
};
typedef std::map <VOP_Node*, VOP_MergeNodeInfo> TMergeNodeInfos;

class VOP_API VOP_VarInfo
{
public:
    VOP_VarInfo() : myDescription( UT_String::ALWAYS_DEEP ) {}

    UT_String           myDescription;      // variable description
    VOP_ContextType     myContextType;      // context type in which var exists
    int                 myVarIndex;         // index in the context's var table
    VOP_TypeInfo        myTypeInfo;         // variable type (int, float, etc)
    bool                myReadable;         // can read from variable?
    bool                myWritable;         // can write to variable?
    bool                myIlluminanceVar;   // is illuminance?
};

class VOP_API VOP_GlobalVarData
{
public:
     VOP_GlobalVarData( const char * name, const VOP_VarInfo & info );
    ~VOP_GlobalVarData();
    void                        appendInfo( const VOP_VarInfo & info );

    const UT_String &           getName() const 
                                { return myName; }

    const UT_String &           getDescription( VOP_ContextType type ) const;
    const VOP_TypeInfo &        getTypeInfo( VOP_ContextType type ) const;
    int                         getVarIndex( VOP_ContextType type ) const;
    bool                        isReadable( VOP_ContextType type ) const;
    bool                        isWriteable( VOP_ContextType type ) const;
    bool                        isIlluminance( VOP_ContextType type ) const;
    bool                        isValidInContext( VOP_ContextType type ) const;

private:
    template<typename T> T          getInfoMember( VOP_ContextType ctx_type, 
                                               T VOP_VarInfo::*member, 
                                               T default_val ) const;
    template<typename T> const T    &getInfoMemberRef( VOP_ContextType ctx_type,
                                               T VOP_VarInfo::*member, 
                                               const T & default_val ) const;
    int                     getIndexForContextType( VOP_ContextType type) const;

private:
    UT_String                   myName;         // variable name
    UT_RefArray<VOP_VarInfo>    myInfos;        // infos for applicable contexts
};

class VOP_API VOP_OutputNameEditorSource
{
public:
    virtual             ~VOP_OutputNameEditorSource();
    virtual int          getNumInputsFromParent() const = 0;
    virtual void         NAMEFROMPARM(UT_String &str, int idx) const = 0;
    virtual void         LABELFROMPARM(UT_String &str, int idx) const = 0;
    virtual void         setNAMEFROMPARM(UT_String &str, int idx) = 0;
    virtual void         setLABELFROMPARM(UT_String &str, int idx) = 0;
};

class VOP_API VOP_Node : public OP_Network
{
public:
    virtual const char  *getChildType() const;
    virtual const char  *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;

    ///  Nobody should have to override this, but it's public for other people
    virtual OP_DATA_TYPE getCookedDataType() const;

    /// Whenever a variable type parm changes, we have to send out an event
    /// to get our tile to update.
    virtual void         opChanged(OP_EventType reason, void *data=0);
    virtual void         referencedParmChanged(int pi);
    
    static void          buildOperatorTable(OP_OperatorTable &table);

    /// Get the parm block information that will go in the dialog script
    /// for our VOPNET. The shader_contexts argument is a list of
    /// contexts, in which the parameter is a shader argument.
    virtual void         getParameterBlock(UT_String &parmstr,
                                           const char *shader_contexts);

    /// The parameter variable declaration using the syntax of a given language.
    virtual void         getParameterDeclaration(UT_String &parmdecl,
                                            const VOP_Language *language,
                                            const VOP_ContextType *type);
    virtual void         getPragmas(UT_String &pragmastr,
                                            VOP_ContextType context_type);
    virtual void         getOuterCode(UT_String &codestr);
    virtual void         getCode(UT_String &codestr, 
                            VOP_CodeVarMapperContext *context=NULL);
    virtual bool         getParmConstantString(const char *parmname,
                                               VOP_Type type,
                                               UT_String &str,
                                               bool expand_string,
                                               const VOP_Language *l=0);
    /// Applies mainly to subnets, and is similar to getCode(), which obtains
    /// VFL code that appears before the { and the code generated by subnet's
    /// children, but this method obtains code that appears after the } and
    /// the children's code.
    virtual void         getPostSubnetCode(UT_String &post_code);

    /// Returns true if this VOP is a VOP_ParmGenerator or subclass.
    virtual bool         getIsParmGenerator() const;

    /// Returns true when this VOP is a VOP_ParmGenerator and it's also an
    /// export parameter in a given context type. 
    /// @param  context_type context type to which the query applies
    /// @param  varname      outgoing parameter that will contain the export 
    ///                      parameter name.
    virtual bool         getExportParm(VOP_ContextType context_type,
                                       UT_String &varname);

    /// Gives the node a chance to initialize itself when it is first created.
    /// This is only used for VOP_ParmGenerator nodes.
    virtual void         initializeNode();

    /// Make sure that our parmname parameter (if we have one) doesn't
    /// conflict with any other parmname parameter values.
    virtual void         ensureParametersAreValid();
    static void          incrementVariableName(UT_String &varname);

    /// Functions to get information about our operator outputs.
    /// These just call the getOutputXXXSubclass functions.
    virtual void         getOutputName(UT_String &out, int idx) const;
    virtual int          getOutputFromName(const UT_String &out) const;
    VOP_Type             getOutputType(int idx);
    void                 getOutputTypeInfo(VOP_TypeInfo &type_info, int idx);
    VOP_Type             getNamedOutputType(const OP_ConnectorId& output_name);
    void                 getNamedOutputTypeInfo(VOP_TypeInfo &type_info,
                                            const OP_ConnectorId& output_name);

    /// Returns the variable name associated with a given input number.
    /// These just call the getInputXXXSubclass functions.
    virtual void                 getInputName(UT_String &in, int idx) const;
    virtual int                  getInputFromName(const UT_String &in) const;
    /// will_autoconvert_out, if not null, is set to true if autoconversion
    /// will be needed, to false otherwise.
    VOP_Type             getInputType(int idx);
    void                 getInputTypeInfo(VOP_TypeInfo &type_info, int idx);
    VOP_Type             getNamedInputType(const OP_ConnectorId& input_name);
    void                 getNamedInputTypeInfo(VOP_TypeInfo &type_info,
                                           const OP_ConnectorId& input_name);

    //  Whether the visibility flag has been set in the operator type property.
    //  This is not the same flag as the one in OP_Input.
    virtual bool        getIsVisible(int idx);
    /// Returns all allowed input types on a given input, regardless of what
    /// is currently connected to that input. These do not include types
    /// to which autoconversion is possible.
    virtual void         getAllowedInputTypes(unsigned idx,
                                              VOP_VopTypeArray &voptypes);
    
    /// Obtains the current signature name and returns true on success and
    /// false otherwise. The VOP signature name applies mostly to the VOP HDAs,
    /// where a user can define several signatures  for the operator (a
    /// signature is a set of input types, and the user provides one name
    /// associated with each such set). The build-in operators ususally have
    /// only a single signature, and thus don't bother to provide any
    /// distinguishing name for it (but they may).
    virtual bool         getCurrentSignatureName(UT_String &name);

    /// Returns whether or not this op outputs variabls in a given context.
    /// If so, the second function returns the name of this output variable.
    virtual bool         areOutputVariablesFixed(VOP_ContextType context_type);
    virtual void         getFixedOutputVariable(UT_String &var, int idx);

    /// Most variables are passed into the subnet by value through the
    /// input node and then referenced by a child node through a wire 
    /// connecting to that input node. Some (thankfully few) nodes however
    /// need to reference a parent subnet's variable without going through
    /// the input node. Such nodes specify the names of selected parent's 
    //variables through this method.
    virtual void         getVariablesImportedFromParentSubnet( 
                                            UT_StringArray & ref_vars );

    /// Recurse through our inputs and add them in order to the given list.
    /// Note this this might create new auto-conversion nodes in this list,
    /// and these will have to be deallocated by the caller (using
    /// the utility function deleteAutoConvertNodesIn())
    void                 mergeInputNodeList(VOP_NodeList &nodes, 
                                            TMergeNodeInfos &merge_infos);

    /// Scans the node list and deletes the auto convert nodes (and replaces
    /// them with NULLs in the list). Also, clears any auto-convert information
    /// for all other nodes in the list. Note, thet the node list is usually
    /// constructed with mergeInputNodeList() method.
    static void          deleteAutoConvertNodesIn(VOP_NodeList& nodes);

    /// Determines if the code generation should collect code-generating nodes 
    /// by recursively traversing the input nodes starting from this node.
    /// This returns true for nodes such as: output node, output variable,
    /// code node, print node, etc, and returns false for nodes such as
    /// global variables, add node, etc.
    /// The essential flag is used to urge the nodes to report true if they 
    /// really think they are essential. This was introduced with multi-context
    /// vopnets because previously a wide range of nodes would report true (eg,
    /// a null, as context-specific subnets) which would then make way into 
    /// incompatible contexts. The essential flag is meant to weed out all 
    /// such nodes and only let through output and export variables nodes.
    virtual bool         forceCodeGenerationOfInputs(
                                        VOP_ContextType context_type,
                                        bool essential) const;

    /// Check to see if this is a subnetwork which generates an encapsulated
    /// shader.  For example the SubnetCVEX VOP.
    virtual bool         getIsEncapsulatedShader() const;
    /// Update the parameters for the encapsulated shader
    virtual void         updateEncapsulatedParameters(const VOP_CodeParmList &parms);
    /// Get a shader name for the encapsulated shader.  This shader name can be
    /// unique based on the session.
    /// For non-encapsulated shaders, this method returns false and leaves the
    /// name buffer un-modified.
    virtual bool         getEncapsulatedShaderName(UT_WorkBuffer &name) const;

    /// Get the "op:" shader name (used when building shader strings).
    virtual bool         getEncapsulatedShaderPath(UT_WorkBuffer &name) const;

    /// Check to see if this VOP is a "scripted shader".  That is, a VOP which
    /// has a shader output, but isn't defined by a VOP network (i.e. it's
    /// defined by either pre-compiled VEX code or C++ code for procedurals).
    virtual bool        getIsScriptedShader();

    /// Get the shader name.
    virtual bool        getScriptedShaderName(UT_WorkBuffer &name);

    /// Get or set the table of global or local variables for this context.
    /// The global variables are defined solely by the VEX context. The
    /// data associated with each entry is the VEX_Type of the variable.
    /// The local variables are those defined by Parameter ops. This
    /// table provides a common place to look for variable name conflicts.
    const UT_SymbolTable*getGlobalVariables() const;
    const UT_SymbolTable*getLocalVariables() const;
    const UT_SymbolTable*getLocalChannels() const;
    void                 setTables(const UT_SymbolTable *globals,
                                   UT_SymbolTable *locals,
                                   UT_SymbolTable *channels);
    void                 setTablesFromVop(VOP_Node *vop);
    void                 addLocalVariable(const char *varname,
                                          VOP_ParmGenerator *definer);
    void                 deleteLocalVariable(const char *varname);
    void                 getSortedGlobalVariableList(VOP_GlobalVarList &vars,
                                                     VOP_ContextType type,
                                                     bool mustBeReadable,
                                                     bool mustBeWritable);

    /// Functions for getting and setting the in/out LOD value, using the
    /// OP_NodeFlag mechanism.
    virtual void         setExtraFlag(char flag, int onoff);
    int                  setInOutLOD(int level, int inoff);
    int                  getInOutLOD(int level) const;
    static int          &getLODPref() { return theLODPref; }
    static void          setLODPref(int value);

    /// Override the setInput functions so that we can send notification to
    /// the nodes that are our inputs when we disconnect from them.
    virtual OP_ERROR     setInput(unsigned idx, OP_Node *op,
                                  unsigned outputIdx = 0);
    virtual OP_ERROR     setInputReference(unsigned idx, const char *label,
                                           int keeppos, unsigned outputIdx = 0);

    virtual OP_ERROR     setNamedInput(const OP_ConnectorId&  input_name, OP_Node *op,
        const OP_ConnectorId* output_name = NULL);
    virtual OP_ERROR     setNamedInputReference(const OP_ConnectorId& input_name, 
                        const char *label, int, const OP_ConnectorId* output_name = NULL);

    /// For subnet VOPs, when moving an input, we want to go in and
    /// reorganize the connections to our subinput and suboutput nodes
    /// so that the internal connections remain the same.
    virtual void         moveInput(int srcidx, int dstidx,
                                   bool forcesubnet = false);

    /// Return our input node for the give index. If recursive is true and we
    /// are in a subnet and the direct input for inputidx is a subnet input
    /// node, travel up the parent chain until no longer in a subnet or the
    /// input node is not a subnet input node. Basically, we want to know if we
    /// are connected to anything meaningful.
    virtual bool         isConnected(int inputidx, bool recursive);

    /// Returns a pointer used by OPUI_OutputNameEditor to get and set data.
    virtual VOP_OutputNameEditorSource  *getOutputNameEditorSource()
                         { return 0; }

    /// Used by subnet type operators which must always have an output node.
    /// However, some specialty subnets, such as volume sampler, may return
    /// NULL, since its output node is not a regular subnet output node that
    /// determines subnet output connectors (which is for what the subnet base 
    /// class uses the output node returned by this method).
    virtual VOP_Node    *getSubnetOutputNode() const;

    /// Returns true if the node is considered a subnet's input node.
    virtual bool         isSubnetInput() const
                            { return false; }

    /// Create a Parameter or Constant VOP that matches the type, name and
    /// value of one of our inputs, and connect it to that input. 'parm'
    /// specifies whether to build a Parameter or a Constant.
    VOP_Node            *insertParmGenerator(int inputidx, bool makeparmnode);
    VOP_Node            *insertNode(int inputidx, const char* nodetype, bool connect_to_input, const char* undo_string = NULL);

    /// When inserting a parameter (i.e. Promote Parameter), the source VOP is
    /// allowed to give us a source VOP_ParmGenerator if there's no
    /// corresponding parameter found.  The source parm generator is used to
    /// initialize settings on the new parameter node.
    virtual VOP_ParmGenerator   *getInsertParmGeneratorSource(int inputidx);
    
    /// Create Parameter or Constant VOPs for all inputs of this node. We
    /// don't create nodes for inputs that are already connected.
    void                 insertParmGeneratorsForAllInputs(bool makeparmnodes);

    /// The following method is needed to obtain the parameter name to be
    /// associated with an input.  It is possible that the parameter name
    /// differs from the input name.
    virtual void         getParmNameFromInput(UT_String &parmname,
                                              int inputidx) const;

    /// Based on the specified input index, output a parm definition block
    /// appropriate for a dialog script. The parm definition provides a
    /// default value for the input if it is not connected. If the input is
    /// VEX_TYPE_UNDEF, we output nothing and return false. Otherwise we return
    /// true.
    bool                 outputDefaultParmDefinition(ostream &os, int idx);

    virtual void         saveDialogScriptExtraInfo(ostream &os);

    /// Saves the parameter values to the output stream.
    bool                 saveParmValues(ostream &os);
    /// Loads the parameter values to the output stream.
    bool                 loadParmValues(UT_IStream &is);

    /// This virtual is overridden by VOP_ParmGenerator so we can find out
    /// which VOP defines the actual parameter attributes.
    virtual VOP_Node    *getRealDefinition()
                         { return 0; }

    const VOP_Language  *getLanguage() const
                         { return myLanguage; }

    /// Absolute width
    virtual fpreal       getW() const;
    /// Absolute height
    virtual fpreal       getH() const;

    virtual fpreal       getYOffset() const;

    /// Override clearInterrupted so that we don't recook the whole DOP Network
    /// when the user interrupts a cook. The clearInterrupted on the containing
    /// VOP Network willb be enough.
    virtual void         clearInterrupted();

    /// Returns EITHER the number of input buttons, or the number of output 
    /// buttons currently displayed on this VOP, which depends on our level of 
    /// detail (LOD). Set 'input_flag' to TRUE to count input buttons, 
    /// false to count output buttons. The value returned does NOT include an 
    /// ellipsis even if one is displayed. If there is an ellipsis, the 
    /// parameter 'ellipsis' will instead be set to true (else set to false).
    void                 getDisplayedButtonCount(bool input_flag,
                                                 int &count,
                                                 bool &ellipsis) const;

    /// Calls cacheParmName on all VOP_ParmGenerator nodes under root.
    static void          cacheAllParmNames(OP_Node *root);
    /// Calls recalculateParmDefiner on all VOP_ParmGenerator nodes under root.
    static void          recalculateAllParmDefiners(OP_Node *root);

    /// Returns true if the input will be auto-converetd, false otherwise.
    virtual bool         willAutoconvertInputType(int input_idx);

    /// Returns the type to which the input will be auto-convert. This is necessary
    /// because some inputs can take in a range of various types, and we need to know
    /// which one will be converting to. This function assumes that autoconversion is
    /// necessary. If it is not possible, or not needed, it returns VOP_TYPE_UNDEF.
    VOP_Type             getAutoConvertTargetType(int input_idx);

    /// Similar to the getAutoConvertTargetType(), but takes in an input type instead
    /// of trying to read it from the connected node. This is useful when one needs to 
    /// know what the incoming type will be converted to before it is actually connected.
    VOP_Type             getAutoConvertTypeFromType(int input_idx, VOP_Type source_type);

    /// Do not call this method directly.
    void                 addAutoConvertNodePointer(VOP_AutoConvert* ac_node, int input_index);
    void                 clearAutoConvertInfos(void);
    VOP_AutoConvert*     getAutoConvertNode(int input_idx);
    int                  getNumAutoConvertNodes(void);

    /// Returns the output information manager. The manager is responsible for manipulating
    /// VOP_OutputInfo objects for each output. These objects dictate how an output behaves
    /// when the node is in debug or bypass mode. See VOP_OutputInfo for more information.
    /// Please note that by default, an output info does not exist for any outputs, and 
    /// is only created when a debug/bypass value is changed.
    VOP_OutputInfoManager* getOutputInfoManager(void);

    /// Appends code which overrides output values if necessary (uses myOutputInfos
    /// below to determine this).
    void appendOutputOverrideCode(UT_String& str_code);

    /// If this returns false, getCode() will not be called during code generation on this node
    /// (appendOutputOverrideCode() still will). This is useful when all outputs of this node
    /// are overriden, and no execution is necessary.
    bool needToExecute(void);

    /// Do not call this method directly.
    void onNodeChange(OP_EventType type);

    virtual OP_ERROR     save(ostream &os, const OP_SaveFlags &flags,
                              const char *path_prefix = "");
    virtual bool         load(UT_IStream &is, const char *ext="",
                                              const char *path=0);

    /// We should not reserve the name of the parameter in 
    /// PI_EditScriptedParms::initializeReserveNames()if it 
    /// is one of our inputs. This function implements this 
    /// behaviour.
    virtual bool         allowReservingParm(PRM_Parm* parm);  

    /// Gets the value of the debug flag on this node.
    virtual int          getDebug() const;
    /// Sets the value of the debug flag on this node.
    virtual int          setDebug(int on_off);

    void                 getSubOutputAndSubInputs(OP_Node *&outputnode,
                                      OP_NodeList &inputnodes) const;

    void                hideInput(int input_index, bool hide); 
    void                setReferenceTargetDefaults(int input_index, bool do_set);
    bool                getAllowEditingParmDefaults(int input_index);

    /// Determine the VEX context type if the node is single-context type.
    /// For nodes in a multi-context vopnet (or for RSL vopnet) returns
    /// VEX_INVALID_CONTEXT, because the specific VEX context cannot be 
    /// reliably and unambiguously determined.
    VEX_ContextType      getVexContextType() const;

    /// Determine the VEX context type if the node is single-context type.
    /// For nodes in a multi-context vopnet (or for VEX vopnet) returns
    /// RSL_INVALID_CONTEXT, because the specific RSL context cannot be 
    /// reliably and unambiguously determined.
    RSL_ContextType      getRslContextType() const;

    /// Determines if the vop can be interpreted as a single or several RSL/VEX
    /// context types (surface, disp, ..), by looking at code generator.
    /// Returns true if the vop node is multi-type and false if single-type.
    bool                 isSingleContextType() const;

    /// Gets the context type (VEX_ContextType or RSL_ContextType) to which
    /// this node subscribes. 
    /// In single-type vopnets, it is equal to the node's VEX/RSL context type.
    /// In multi-type vopnets, the exact type is variable and usually 
    /// depends on the node's parameter value.
    VOP_ContextType      getShaderContextType() const;

    /// Returns true if the node can generate code in the given context.
    /// For nodes in a single-context vopnet it returns true if the given type
    /// is exactly the same as specified by the parent vopnet. 
    /// For multi-context vopnets, the nodes usually specify the list of
    /// accepted types, and this method tests given type against that list.
    bool                 acceptsTypeForCodeGeneration(VOP_ContextType t) const;

    /// Returns true if the node provides or represents procedural or
    /// encapsulated shader code, or any other vop that has a code generator
    /// capable of generating shader code for this node.
    virtual bool         providesShaderCode();

    /// Tests if this node is trully a procedural of a given type,
    /// and returns this pointer if so, or NULL otherwise.
    /// The test is done by verifying that the node has an output of the 
    /// shader type specified by @c type.
    VOP_Node            *verifyProcedural(VOP_Type type);

    /// Returns a parmmap string array where alternate entries contain key and
    /// value, where key is the vop parameter name and the value is the
    /// parameter name specified by the Parm VOP connected to the input
    /// corresponding to that vop parameter.
    virtual void         getFixedParameterMap(UT_StringArray &parmmap);

    /// Returns an input map string array where alternate entries contain
    /// key and value, where key is the vop parameter name and the value is the
    /// node path specified for that parameter (usually connected into an
    /// input corresponding to that vop parameter).
    virtual void         getShaderInputMap(UT_StringArray &inputmap);

    /// Obtains the template array for shader parameters.
    virtual const PRM_Template  *getShaderParmTemplates();

    /// Deletes the input nodes for a given input (recursively), but
    /// only if none of them depend on anything other than this node.
    /// Returns true if any nodes were deleted, false otherwise.
    bool                 deleteIndependentInputNodes(int input_index);

    void                 getInputsRecursive(OP_NodeList& nodes_out);
    bool                 doesDependOnlyOn(VOP_Node* other_node, int max_connections, bool recurse);

    /// Search through this node's inputs and return a list of parameter VOPs
    /// that appear in the input network.  Recursively search through
    /// subnetworks as well.  If this node is a parameter VOP, then add
    /// it to the list.
    void                 getParmInputs(VOP_ParmGeneratorList &parm_vops);

    /// Returns the node wired to this VOP's 'index' input tracing past
    /// simple VOPs like the Switch or Null VOP.
    VOP_Node            *findSimpleInput(int index);
    /// Virtual helper to findSimpleInput() which returns the simple input
    /// node (ie the final node we look for) based on the request coming
    /// from the node connected to on the output of a given index.
    virtual VOP_Node    *findSimpleInputFromOutput(int output_index) 
                         { return this; }
    /// A method that reports which immediate input connectors are considered
    /// by findSimpleInputFromOutput() method. This is useful when analyzing
    /// the simple input decision tree.
    virtual void         findSimpleInputCandidatesFromOutput(int output_index,
                                            UT_IntArray & input_indices )
                         { input_indices.clear(); }

    /// Returns true if the operator represents an externally defined shader
    /// such as a Geometry Shader.
    bool                 isExternalShader();

    // Runs the creation script (if there is one). The return value is false
    // if the node was deleted while running the script. In this case
    // obviously the node pointer becomes invalid and should not be used
    // any more. It returns true if the node still exists.
    virtual bool         runCreateScript();

    void                 updateInputFlagsFromOperator(VOP_OperatorInfo *type_info, 
                                                bool keep_visible);

    virtual void onCreated(void);

    void                hideNamedInput(const OP_ConnectorId& connector_name, bool hide); 
    /// Returns all allowed input types on a given input, regardless of what
    /// is currently connected to that input. These do not include types
    /// to which autoconversion is possible.
    virtual void         getAllowedNamedInputTypes(const OP_ConnectorId& input_name,
                                              VOP_VopTypeArray &voptypes);

    VOP_Type             getNamedAutoConvertTargetType(const OP_ConnectorId& input_name);
    VOP_Type             getNamedAutoConvertTypeFromType(const OP_ConnectorId& input_name, VOP_Type source_type);
    virtual bool         willAutoconvertNamedInputType(const OP_ConnectorId& input_name);
    VOP_Node            *insertNamedNode(const OP_ConnectorId& input_name, const char* nodetype, bool connect_to_input, const char* undo_string = NULL);

    void                 setDisableAutoInputDelete(bool value) 
            { myDisableInputAutodelete = value; }

protected:
    VOP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
    virtual ~VOP_Node();

    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                        OP_NodeInfoParms &iparms);

    virtual void         deleteCookedData();
    virtual int          saveCookedData(ostream &, OP_Context &,
                                        int binary = 0);
    virtual int          saveCookedData(const char *, OP_Context &);
    virtual const char  *getFileExtension(int) const;

    virtual OP_ERROR     cookMe(OP_Context &);
    virtual OP_ERROR     bypassMe(OP_Context &, int &);

    virtual void         preOpChanged(OP_EventType, void *)
                         { }
    virtual void         postOpChanged(OP_EventType, void *)
                         { }

    /// Gets the shader context type (VEX_ContextType
    /// or RSL_ContextType) to which a node belongs to. 
    ///
    /// This method is meant to be overriden by nodes that can specify a single
    /// concrete context type when they are created in a multi-context vopnet.
    /// This method is invoked by getShaderContextType() to obtain the concrete
    /// type, if possible
    ///
    /// In multi-context vopnets, for nodes that explicitly specify a single
    /// context (such as an output node, usually determined from the node's
    /// parameter), this method returns such explicltly selected context
    /// type. For other nodes that don't explicltly choose a context, this
    /// method returns an invalid type, meaning such nodes don't have control
    /// over a specific type, and they belong to a type specified during code
    /// generation.
    virtual VOP_ContextType     getSpecificShaderContextType() const;

    /// Obtains a list of types in which this node wants to initiate
    /// the generation of code.
    virtual void                getTypesForCodeGeneration(
                                        VOP_ContextTypeList & types ) const;

    /// Functions to get information about our operator outputs.
    /// These functions are used for variable name replacement and for
    /// creating output labels on the op tiles.
    virtual void         getOutputNameSubclass(UT_String &out, int idx) const;
    virtual void         getOutputTypeInfoSubclass(VOP_TypeInfo &type_info, 
                                                   int idx);
    // Depreciated in favour of getOutputTypeInfoSubclass():
    virtual VOP_Type     getOutputTypeSubclass(int idx);

    /// Returns the variable name associated with a given input number.
    /// Implementers of this function should also implement the reverse
    /// function.
    virtual void         getInputNameSubclass(UT_String &in, int idx) const;
    virtual int          getInputFromNameSubclass(const UT_String &in) const;
    virtual void         getInputTypeInfoSubclass(VOP_TypeInfo &type_info, 
                                                  int idx);
    // Depreciated in favour of getInputTypeInfoSubclass():
    virtual VOP_Type     getInputTypeSubclass(int idx);
    virtual bool         getIsVisibleSubclass(int idx);

    /// A helper method that obtains the idx-th input type info from the 
    /// connected input node. If not connected, type info is set to undefined.
    /// @param  type_info   The type info to fill out.
    /// @parm   idx         The index of the input from where to take the type.
    /// @param  grow_inputs_to_idx 
    ///                     If true and the the requested idx is larger than
    ///                     the input list size, then the list is expanded
    ///                     to make the requested index legal. Otherwise,
    ///                     list is kept constant and input is treated as NULL,
    ///                     resulting in an info for an undefined type.
    /// @return             True if the info was obtained from the vop,
    ///                     otherwise false (info is set to undef, by default).
    bool                 getInputTypeInfoFromInputNode( 
                                    VOP_TypeInfo &type_info, int idx, 
                                    bool grow_inputs_to_idx = false);

    /// This methods should be overriden in most VOP nodes. It should fill
    /// in voptypes vector with vop types that are allowed to be connected
    /// to this node at the input at index idx. Note that 
    /// this method should return valid vop types even when nothing is 
    /// connected to the corresponding input.
    virtual void         getAllowedInputTypesSubclass(unsigned idx,
                                              VOP_VopTypeArray &voptypes);

    /// If the can only accept parameters as inputs, this method should return
    /// true.  By default, this method checks the operator to see whether the
    /// VOP relies on external code (i.e. geometry procedurals)
    virtual bool         getRequiresInputParameters() const;

    void                 addError(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddError("VOP", code, msg); }
    void                 addMessage(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddMessage("VOP", code, msg); }
    void                 addWarning(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddWarning("VOP", code, msg); }
    void                 addFatal(VOP_ErrorCodes code, const char *msg=0)
                         { UTaddFatal("VOP", code, msg); }

    /// This function is used to rewire nodes when we do a moveInput.
    static void          rewireInputs(OP_Network *parent, OP_NodeList &inputs,
                                      int srcidx, int dstidx);

    const VOP_Language  *myLanguage;

    virtual void        getAdditionalUndoNodes(const OP_NodeList& orig_list, OP_NodeList& nodes_for_input_undo);

    /// Save and load VOP version numbers
    virtual OP_ERROR     saveIntrinsic(ostream &os, const OP_SaveFlags &flags);
    virtual bool         loadPacket(UT_IStream &is, short class_id,
                                    short sig, const char *path = 0);
    virtual bool         loadPacket(UT_IStream &is,
                                    const char *token, const char *path = 0);

    /// If a subclass has VOP versioning, it should return a value greater
    /// than 0 for the latest version.
    virtual int          getLatestVopVersion() const    { return 0; }

    void                 getInputsRecursiveHelper(OP_NodeList& nodes_out, UT_RefArray<int> &array);
    
    bool                 doesDependOnlyOnHelper(VOP_Node* other_node, int max_connections, 
                                                bool recurse, UT_RefArray<int> &array);

    virtual void         onInputAllocated(OP_Input* new_input, int index);

    virtual void         finishedLoadingNetwork(bool is_child_call=false);

    int                  myVopVersion;

private:
    /// Returns true if this node can access illuminance global variables.
    bool                 getIncludeIllumVars() const;

    /// Helper method for opChanged().
    /// Propagates the node change to the VOP code generator
    /// so that the code is re-generated and the exported parameters
    /// are updated.
    void                 propagateOpChangeToCodeGenerator(
                                                OP_EventType reason) const;

    /// Report a recursive loop error.
    void                 reportRecursiveLoopError();

    const UT_SymbolTable*myGlobalVariables;
    UT_SymbolTable      *myLocalVariables;
    UT_SymbolTable      *myLocalChannels;
    long                 myLatestOpChangedId;
    bool                 myMakingInputList;
    bool                 myIsSearchingForParmInputs;
    bool                 myDisableInputAutodelete;
    mutable UT_BitArray  myGettingInputName;
    mutable UT_BitArray  myGettingInputTypeInfo;
    mutable UT_BitArray  myGettingIsVisible;
    mutable UT_BitArray  myGettingAllowedInputTypes;
    mutable UT_BitArray  myGettingOutputName;
    mutable UT_BitArray  myGettingOutputTypeInfo;
    mutable int          myOutputNodeId;

    static VOP_Node     *theOriginalOpChanged;
    static long          theLatestOpChangedId;
    static int           theLODPref;

    TAutoConvertInfos   myAutoConvertInfos;
    VOP_OutputInfoManager   myOutputInfos;

    UT_SymbolTable                  myCachedOutputNames;
    UT_PtrArray< VOP_TypeInfo* >    myCachedOutputTypeInfos;
};

#endif

---