VOP_ScriptNode.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_ScriptNode.h ( VOP Library, C++)
 *
 * COMMENTS:    This is the meat & potatoes.  Here we have an operator which is
 *              defined by a script.
 */

#ifndef __VOP_ScriptNode__
#define __VOP_ScriptNode__

#include "VOP_API.h"
#include "VOP_Node.h"

class VOP_ScriptOperator;

class VOP_API VOP_ScriptNode : public VOP_Node {
public:
             VOP_ScriptNode(OP_Network *dad, const char *name, OP_Operator *op);
            ~VOP_ScriptNode() override;

    static OP_Node      *myConstructor(OP_Network *net, const char *name,
                                       OP_Operator *op);
    static PRM_Template  myMultiInputSetTemplateList[];

    void                 initMaterialFlag() 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                 getParmConstantString(
                                const char *parmname,
                                const VOP_TypeInfo &type_info,
                                UT_String &str,
                                bool expand_string,
                                const VOP_Language *language=nullptr) override;

    void                 ensureParametersAreValid() override;

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

    int                  getSignatureCount() const override;
    void                 getSignatureName(
                                UT_String &name, int index) const override;
    void                 setCurrentSignature(const char *name) override;
    bool                 getCurrentSignatureName(UT_String &name) override;
    UT_StringHolder      getShaderNameForSignature( 
                                const UT_StringRef &signature) const override;

    bool                 allowUSDShaderParm(PRM_Parm &parm) override;

    void                 getAllowedInputTypeInfos(
                                unsigned idx,
                                VOP_VopTypeInfoArray &voptypes) override;

    bool                 isShader() const override;
    bool                 isShader(VOP_Type shader_type) const override;
    bool                 isCachedShader() const override;
    bool                 getCachedShaderCode(
                                std::ostream &os,
                                VOP_ContextType context_type) const override;
    bool                 forceCodeGenerationOfInputs(
                                const VOP_CodeGenContext &context,
                                bool check_shader_context) const override;

    void                 getParmNameFromInput(UT_String &parmname,
                                              int inputidx) const override;

    static void          buildInputSetMenu(void *, PRM_Name *, int,
                                           const PRM_SpareData *,
                                           const PRM_Parm *);
    int                  getCurrentInputSet() const;

    /// Updates the opeartor information about inputs and outputs based on the
    /// current state of the script node.
    /// If 'keep_info' is true, most of the op_info is preserved (eg, input
    /// order, input visibility flags, etc), and this method updates the data 
    /// that can be specifed only by the node itself (and not op type 
    /// properties editor). Otherwise, if false, node inptus will dictate
    /// the saved order and flags.
    void                 updateInputsAndOutputsInfo(VOP_OperatorInfo *op_info,
                                bool keep_info = false);
    virtual bool         getIsInputDefinedByParmChild(int idx) const;
    virtual bool         getIsOutputDefinedByParmChild(int idx) const;

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

    bool                 definesShaderExtraParameters() const override;
    int                  getShaderExtraParameters(
                                UT_Array<VOP_Type> &types,
                                UT_IntArray &doexport,
                                UT_StringArray &names,
                                UT_StringArray &def,
                                VOP_Type shader_type = VOP_TYPE_UNDEF
                                ) const override;
protected:
    void                 updateCurrentInputSet();

    bool                 updateParmsFlags() override;
    
    unsigned             getNumScriptOpInputs() const;
    const UT_StringHolder &getScriptOpInputName(int idx) const;
    int                  findScriptOpInput(const char *input_name) 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                 getIsInputVisibleDefaultSubclass(int idx) override;
    void                 getAllowedInputTypeInfosSubclass(
                                unsigned idx,
                                VOP_VopTypeInfoArray &voptypes) override;

    unsigned             getNumScriptOutputs() const;
    int                  findScriptOpOutput(
                                const UT_StringRef &output_name) const;
    void                 getOutputNameSubclass(
                                UT_String &out, int idx) const override;
    void                 getOutputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, int idx) override;

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

    void                 getVopFunctionName(
                                UT_String &function_name) const override;

private:
    bool                 getBestMatchingParameter(UT_WorkBuffer &parm,
                                        const char *input, int inputidx) const;
    bool                 getBestMatchingInput(int &input_index, 
                                        const UT_String &input_name) const;
    bool                 shouldOutputNodeVariableDeclarations() const override;

    bool                 getHideInputsUsingParameterVisibleState() const;

private:
    VOP_ScriptOperator  *myScript;
    int                  myCurrentInputSet;
    UT_IntArray          myValidInputSets;
    bool                 myUpdatingInputSetFlag;
};

#endif