VOP_SubnetBase.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++)
 *
 * COMMENTS:    The base class for all subnet VOP operators
 *
 */

#ifndef __VOP_SubnetBase_h__
#define __VOP_SubnetBase_h__

#include "VOP_API.h"
#include "VOP_Node.h"
#include "VOP_ExportedParmsManager.h"
#include <UT/UT_StringArray.h>

class VOP_SubnetHelper;

class VOP_API VOP_SubnetBase : public VOP_Node
{
public:
    OP_OperatorFilter   *getOperatorFilter() override;

    void                 getCode(UT_String &codestr,
                                 const VOP_CodeGenContext &context) override;

    const char          *inputLabel(OP_InputIdx idx) const override;
    const char          *outputLabel(OP_OutputIdx idx) const override;

    unsigned             getNumVisibleInputs() const override;
    unsigned             getNumRealInputs() const;
    unsigned             getNumVisibleOutputs() const override;
    unsigned             orderedInputs() const override;
    
    void                 getNodeSpecificInfoText(
                                OP_Context &context,
                                OP_NodeInfoParms &iparms) override;

    // When one of our inputs changes, we may want to rearrange things on
    // our subnet input and subnet output nodes.
    OP_ERROR             setInput(OP_InputIdx idx, OP_Node *op,
                                  OP_OutputIdx outputIdx = 0) override;
    OP_ERROR             setInputReference(
                                OP_InputIdx idx,
                                const char *label,
                                int keeppos,
                                OP_OutputIdx outputIdx = 0) override;
    OP_ERROR             setNamedInput(
                                const OP_ConnectorId& input_name,
                                OP_Node *op,
                                const OP_ConnectorId* output_name = nullptr
                                ) override;
    OP_ERROR             setNamedInputReference(
                                const OP_ConnectorId&  input_name, 
                                const char *label,
                                int,
                                const OP_ConnectorId* output_name = nullptr
                                ) override;


    bool                 isConnected(int inputidx, bool recursive) override;

    const VOP_SubnetBase *castToSubnetBase() const override { return this; }
    VOP_SubnetBase       *castToSubnetBase() override { return this; }

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

    VOP_ExportedParmsManager *getVopExportedParmsManager(
                                        bool create_if_needed=false) override;
                                    
    static const char   *theChildTableName;

protected:
    VOP_SubnetBase(OP_Network *parent, const char *name, OP_Operator *entry);
    ~VOP_SubnetBase() override;

    bool                 updateParmsFlags() override;
    virtual bool         shouldShowInputNext() const;

    UT_StringArray      *getArrayForLoadedInputNames() override;
    UT_StringArray      *getArrayForLoadedOutputNames() override;
    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                 addNode(OP_Node *node, int notify=1,
                                 int explicitly=1) override;
    bool                 isOperatorAllowedInTabMenu(OP_Operator *op) override;

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

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

    /// @{ Methods for handling inputs defined by a parm vop children
    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();
    void                 setupConnectorDefinersAfterLoad();
    void                 addConnectorDefinerAfterLoad(VOP_ParmGenerator *pg);
    /// @}

    virtual void         getInternalInputName(UT_String &in, int idx) const;

    virtual int          getNumDefinedInputs() const;
    virtual void         getDefinedInputDefault(UT_String &def, int idx) const;
    void                 getInputDefaultValue(
                                UT_String &def, int idx) const override;

    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;
    void                 getAllowedInputTypesSubclass(
                                unsigned idx,
                                VOP_VopTypeArray &voptypes) override;
    bool                 allowConsolidatingInput(int idx) 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;

    /// Number of extra outputs a subnet subclass may want to provide, in 
    /// addition to outputs defined by this base class (and sub output child).
    virtual int          getNumCustomOutputs() const;

    /// Number of extra outputs on the subnet node in addition to the
    /// outputs defined by the Subnet Output child vop inside.
    int                  getNumNodeDefinedOutputs() const override;
    int                  getNumSubnetInputsForChildren() const override;
    int                  getSubnetInputIndexForChildren(
                                int index) 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;

    bool                 isInputConnectedInsideSubnet(
                                int input_idx) const override;
    bool                 isNamedInputConnectedInsideSubnet(
                                const OP_ConnectorId& input_name
                                ) const override;

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

    /// Virtuals for handling input order editing.
    int                  getInputEditorInputs() override;
    bool                 getInputEditorInputLabel(
                                UT_String &label, int idx ) override;
    void                 moveInput(
                                int srcidx,
                                int dstidx,
                                bool forcesubnet = false) override;
    void                 doDeleteInput(int idx) override;


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

private:
    /// inputnull is true if the input is about to become null, and false if it
    /// is about to be connected.
    void                 adjustChildrenForInputChange(int idx, 
                                    int child_input_idx,
                                    bool inputnull, bool force, 
                                    bool allow_disconnection, 
                                    bool allow_connection);
    int                  preSetSubnetInput(int idx, bool inputnull);
    void                 postSetSubnetInput(int idx, bool inputnull, 
                                    int child_input_idx);
    void                 findSafeBase(UT_String &in) const;
    bool                 isConnectedInside(int idx,
                                           bool include_outputs,
                                           bool include_parm_definers) const;
    // Note that this expects a subnet input name, i.e. the name not yet 
    // prefixed with VOP_SUBNET_VARIABLE_PREFIX.
    bool                 isConnectedInsideNamed(
                                const OP_ConnectorId& input_name,
                                bool include_parm_definers) const;
    void                 deleteArraysForLoadedInputAndOutputNames();

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

    friend class SubnetAPI;

    UT_StringArray               myInputNames;
    unsigned                     myIsAdjustingForInputChange : 1,
                                 myIsAppendingDefinedInput : 1,
                                 myIsSettingUpConnectorDefinersAfterLoad : 1,
                                 myIsLoadingNetwork : 1,
                                 myAreConnectorsSetUp : 1;

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

    /// Used during loading to find out input and output names.
    UT_StringArray              *myLoadedInputNames;
    UT_StringArray              *myLoadedOutputNames;
};

#endif