VOPNET_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.
 *
 */

#ifndef __VOPNET_Node_h__
#define __VOPNET_Node_h__

#include "VOPNET_API.h"
#include "VOPNET_Error.h"
#include <OP/OP_Network.h>
#include <VOP/VOP_CodeGenerator.h>
#include <VOP/VOP_ExportedParmsManager.h>

class UT_String;


class VOPNET_API VOPNET_Node : public OP_Network
{
public:
    static CH_LocalVariable      myVariableList[];
    static OP_Node              *myConstructor(OP_Network* net,
                                               const char* name,
                                               OP_Operator* entry);

    OP_OperatorFilter           *getOperatorFilter() override;
    VOP_CodeGenerator           *getVopCodeGenerator() override;
    bool                         hasVexShaderParameter(const char *parm_name) override;

    const char          *getChildType() const override;
    const char          *getOpType() const override;

    static const char   *theChildTableName;
    OP_OpTypeId          getChildTypeID() const override;
    OP_OpTypeId          getOpTypeID() const override;

    void                 opChanged(OP_EventType reason, void *data=0) override;

    // Local variables for compiler option evaluation
    bool                 evalVariableValue(UT_String &v,int index, int thread) override;
    bool                 evalVariableValue(fpreal &v,int i, int thr) override
                         { return OP_Network::evalVariableValue(v, i, thr); }

    const char          *getInternalOpTable() const override;
    const char          *getInternalIndexFile() const;
    bool                 getShowOpInTabMenuFlag();

    OP_Operator         *getInternalOperator() const override;
    void                 setInternalOperator(OP_Operator *op);
    const UT_String     &getOperatorName() const;

    // Returns true if there are any instances of any operator types
    // defined by us or any of our child nodes.
    bool                 canDestroyNode() override;

    // VOPNET's have no outputs
    unsigned             maxOutputs() const override { return 0; }
    // Absolute width
    fpreal               getW() const override;
    // Absolute height
    fpreal               getH() const override;

    // Handle the old parm order parameter by storing it, so it can later
    // be applied to our output node.
    void                 resolveObsoleteParms(PRM_ParmList *obsolete_parms) override;

    // Get the management ops associated with vopnets...
    static OP_Operator  *getManagementOperator();
    static OP_Operator  *getSOPManagementOperator();
#if 0
    static OP_Operator  *getPOPManagementOperator();
#endif
    static OP_Operator  *getCHOPManagementOperator();
    static OP_Operator  *getCOP2FilterManagementOperator();
    static OP_Operator  *getCOP2GenManagementOperator();
    static void          addSHOPManagementOperators(OP_OperatorTable *table);

    static void          buildOperatorTable (OP_OperatorTable &table);

protected:
             VOPNET_Node(OP_Network* parent, const char* name, 
                         OP_Operator* op);
            ~VOPNET_Node() override;

    void                 getNodeSpecificInfoText(
                                OP_Context &context,
                                OP_NodeInfoParms &iparms) override;
    void                 finishedLoadingNetwork(
                                bool is_child_call=false) override;
    void                 addNode(OP_Node *node, int notify=1,
                                 int explicitly=1) override;

    OP_ERROR             cookMe(OP_Context &context) override;
    OP_ERROR             bypassMe(OP_Context &context,
                                  int &copied_input) override;

    OP_DataType          getCookedDataType() const override;
    void*                getCookedData(OP_Context &) override;
    void                 deleteCookedData() override;
    int                  saveCookedData(const char *, OP_Context &) override;
    int                  saveCookedData(std::ostream &, OP_Context &, 
                                        int bin = 0) override;

    const char          *getFileExtension(int binary) const override;

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

    void                 ensureSpareParmsAreUpdatedSubclass() override
                         {
                            if (getVopCodeGenerator()
                                && eventMicroNode(OP_SPAREPARM_MODIFIED)
                                    .requiresUpdate(0.0))
                            {
                                getVopCodeGenerator()
                                    ->exportedParmsManager()
                                    ->updateOwnerSpareParmLayout();
                            }
                         }

    OP_Operator         *myInternalOperator;
    VOP_CodeGenerator   *myCodeGenerator;
    UT_String            myObsoleteParmOrder;
};

#endif