VOP_SubnetScript.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.
 *
 * NAME:        VOP Library (C++)
 *
 */

#ifndef __VOP_SubnetScript_h__
#define __VOP_SubnetScript_h__

#include "VOP_API.h"
#include "VOP_ExportedParmsManager.h"
#include "VOP_ScriptNode.h"
class VOP_SubnetHelper;
                        
class VOP_API VOP_SubnetScript : public VOP_ScriptNode
{
public:
    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);
    static PRM_Template          myTemplateList[];

    OP_OperatorFilter           *getOperatorFilter() override;

    void                 getModulesToImport(UT_StringArray &modules,
                                const VOP_CodeGenContext &context) override;
    void                 getOuterCode(UT_String &codestr,
                                const VOP_CodeGenContext &context) override;
    void                 getCode(UT_String &codestr,
                                const VOP_CodeGenContext &context) override;

    bool                 forceCodeGenerationOfInputs(
                                const VOP_CodeGenContext &context,
                                bool check_shader_context) const override;

    bool                 canDefineShader() const override;
    void                 getVopFunctionArgInfos(
                                UT_Array<VOP_FunctionArgInfo> &arg_infos
                                ) override;

    bool                 getParmConstantString(
                                const char *parmname,
                                const VOP_TypeInfo &type_info,
                                UT_String &str,
                                bool expand_string,
                                const VOP_Language *l = nullptr) override;

    const char          *inputLabel(unsigned idx) const override;
    const char          *outputLabel(unsigned idx) const override;

    unsigned             maxInputs() const override;
    unsigned             getNumVisibleInputs() const override;
    unsigned             getNumVisibleOutputs() const override;
    int                  getNumNodeDefinedOutputs() const override;
    int                  getNumSubnetInputsForChildren() const override;
    int                  getSubnetInputIndexForChildren(
                                int index) const override;

    bool                 isConnected(int inputidx, bool recursive) override;

    VOP_ExportedParmsManager *getVopExportedParmsManager(
                                        bool create_if_needed=false) override;

    /// Updates the node so new inuts and outputs are taken into account.
    /// If op_info argument is NULL, the current operator op info is queried.
    void                 updateSubnetWithNewOp(const VOP_OperatorInfo *op_info);

    static const char   *theChildTableName;

protected:
    VOP_SubnetScript(OP_Network *net, const char *name, OP_Operator *entry);
    ~VOP_SubnetScript() override;

    UT_StringArray *            getArrayForLoadedInputNames() override;
    UT_StringArray *            getArrayForLoadedOutputNames() override;
    void                        deleteArraysForLoadedInputAndOutputNames();
    VOP_ParmGeneratorMap *      getSubnetVariables() override;

    void                 beginLoadingInNetwork() override;
    void                 endLoadingInNetwork() override;
    void                 loadStart() override;
    void                 finishedLoadingNetwork(
                                bool is_child_call=false) override;
    void                 setupConnectorsAfterLoad() override;
    void                 changeParmTemplate(
                                PRM_Template *new_template) override;
    void                 addNode(OP_Node *node, int notify=1,
                                 int explicitly=1) override;
    bool                 isOperatorAllowedInTabMenu(OP_Operator *op) override;

    /// Invalidates the cached list of contained shaders. 
    bool                 runCreateScript() override;
    void                 dirtyShaderList() override;
    void                 findAllShaders(
                                VOP_NodeList &shader_nodes,
                                VOP_ShaderTypeList &shader_types,
                                UT_StringArray &output_names) override;
    
    /// Returns true if subnet can be translated into Material or NodeGraph.
    bool                translatesDirectlyToUSD() const override;

    /// Overriding these virtuals to control how we create contents network
    /// @{
    void                 matchOTLDefinition() override;
    void                 unmatchOTLDefinition() override;
    void                 handleOTLIndexFileCleared() override;
    /// @}

    /// Inherited from VOP_Node.
    /// Generate the node errors.
    /// Return true if an error was generated and false otherwise.
    bool                 generateErrorsSubclass() override;

    /// Subnet declares own variables, so some types may need to be defined.
    void                 getExtraTypesToDefine(
                                UT_Array<VOP_TypeInfo> &types) override;

    void                 opChanged(OP_EventType reason, void *data) override;
    void                 postOpChanged(
                                OP_EventType reason, void *data) override;

    /// @{ Methods for handling inputs defined by a parm vop children in
    ///    unlocked assets.
    void                 handleChildAdd( OP_Node *child );
    void                 handleChildDelete( OP_Node *child );
    void                 handleDescendentAdd( VOP_Node *descendent );
    void                 handleDescendentDelete( VOP_Node *descendent );
    static void          handleParmNodeChange(OP_Node *caller, void *callee, 
                                OP_EventType type, void *);
    void                 updateConnectorDefiner( VOP_Node *node);
    void                 shaderParmGrandChildAdded(
                                VOP_Node *grand_child) override;
    void                 shaderParmGrandChildDeleted(
                                VOP_Node *grand_child) override;
    void                 shaderParmGrandChildChanged(
                                VOP_Node *grand_child) override;
    void                 setupConnectorDefinersAfterLoadIfNeeded(
                                const VOP_OperatorInfo *op_info);
    void                 setupConnectorDefinersAfterLoad(
                                const VOP_OperatorInfo *op_info);
    void                 addConnectorDefinerAfterLoad(VOP_ParmGenerator *pg,
                                const VOP_OperatorInfo *op_info,
                                UT_Array< VOP_ParmGenerator* > &set_in,
                                UT_Array< VOP_ParmGenerator* > &append_in,
                                UT_Array< VOP_ParmGenerator* > &set_out,
                                UT_Array< VOP_ParmGenerator* > &append_out );
    int                  verifyOpInputIndexForNode(int idx) const;
    /// @}

    void                 getInputNameSubclass(
                                UT_String &in, int idx) const override;
    int                  getInputFromNameSubclass(
                                const UT_String &in) const override;
    void                 getInputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, int idx) override;
    bool                 getIsInputDefinedByParmChild(int idx) const override;
    bool                 getIsOutputDefinedByParmChild(int idx) const override;

    void                 getOutputNameSubclass(
                                UT_String &out, int idx) const override;
    void                 getOutputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, int idx) override;
    UT_IntArray          getShaderLayerExportsInputsToCopy(
                                int out_idx, VOP_Type shader_type) override;
    UT_StringHolder      getShaderLayerExportsToAdd(
                                int out_idx, VOP_Type shader_type) override;
    void                 getSubnetOutputTerminalChild( 
                                VOP_Node * &output_vop,
                                int &input_idx,
                                int subnet_output_idx) const override;

    /// Returns true if output of a given index has an input by the same name.
    bool                 hasCorrespondingInput(int output_idx) const override;

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

    /// Returns true if the subnet script (HDA) is using cached code
    /// rather than generating it from the children.
    bool                 isUsingCachedCode() const
                         { return myIsUsingCachedCode; }

    /// @{ Helpers for managing script info object
    virtual void        loadMaterialInfo();
    virtual void        unloadMaterialInfo();
    /// @}

private:
    struct vop_EncapsulatedMetaData
    {
        vop_EncapsulatedMetaData() : myIsValid(false) {}

        bool                            myIsValid;
        UT_SortedStringMap<UT_String>   myIsConnectedMap;
    };

    bool                 parseMetaDataString(UT_String &str,
                                             vop_EncapsulatedMetaData &md);
    void                 parseEncapsulatedMetaData(const UT_WorkBuffer &code,
                                                   vop_EncapsulatedMetaData &md);

    void                 adjustChildrenForInputRemoval(int idx);
    void                 adjustChildrenForInputInsertion(int idx);

private:
    /// Forward declaration of our embedded VOP_SubnetHelper::SubnetAPI
    /// subclass.
    class SubnetAPI;

    friend class SubnetAPI;

    /// Helper that factors out methods shared with regular subnetwork.
    VOP_SubnetHelper            *mySubnetHelper;

    /// Used during loading to find out input and output names just in case
    /// we need to order Parameter VOP defined inputs/outputs in assets not
    /// matching their definition.
    UT_StringArray              *myLoadedInputNames;
    UT_StringArray              *myLoadedOutputNames;

    /// A flag indicating if node is exclusively using cached vex/vfl code.
    bool                         myIsUsingCachedCode;

    /// We're deleting a mass of nodes. We don't care about knowing whether
    /// we just lost one.
    bool                        myIsDeletingSubnetNodes;

    /// We're in setupConnectorDefinersAfterLoad().
    unsigned                    myIsSettingUpConnectorDefinersAfterLoad : 1,
                                myIsLoadingNetwork : 1,
                                myAreConnectorsSetUp : 1;
};

#endif