VOP_Snippet.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_Snippet_h__
#define __VOP_Snippet_h__

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

class VCC_Location;

class VOP_API VOP_Snippet : public VOP_Node
{
public:
    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);
    static PRM_Template         *buildTemplates();


    static UT_StringHolder       buildOuterCode(
                                    const char *returntype,
                                    const char *funcname, 
                                    const char *boundprefix,
                                    const char *snippet, 
                                    const char *inputlist, 
                                    const char *exportlist, 
                                    bool toplevel,
                                    bool strict_varnames, 
                                    bool vexstrict, 
                                    bool linehints, 
                                    const char *linefile, 
                                    const VOP_Language *language, 
                                    const VOP_GlobalVarMap *globalvariables);

    // Adjusts the location to take into account any bound variables.
    static void          adjustLocation(const char *snippet, bool strict_varnames, VCC_Location &loc);


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

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

    bool                         definesShaderExtraParameters() const override
                                 { return true; }
    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;

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

    unsigned                     getNumVisibleInputs() const override;
    unsigned                     getNumVisibleOutputs() const override;

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

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

    /// The following are used to rewire our inputs so things
    /// remain kosher.
    void                         moveInput(int srcidx, int dstidx,
                                           bool forcesubnet = false) override;

    OP_ERROR                     setInput(unsigned idx, OP_Node *op,
                                          unsigned outputidx = 0) override;
    OP_ERROR                     setInputReference(
                                        unsigned idx, 
                                        const char *label,
                                        int keeppos,
                                        unsigned outputidx = 0) override;

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


    VOP_Node *                   findSimpleInputFromOutput(int index) override;
    void                         findSimpleInputCandidatesFromOutput(
                                        int output_index,
                                        UT_IntArray &input_indices) override;

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

    void                 getDescriptiveParmName(UT_String &name) const override
                         { name = "code"; }
    
    void                 preOpChanged(OP_EventType reason, void *data) 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                 getOutputNameSubclass(
                                UT_String &out, int idx) const override;
    void                 getOutputTypeInfoSubclass(
                                VOP_TypeInfo &type_info, int idx) override;

    void                 adjustOutputParmsForInputChange(int idx,
                                            bool inputnull);
    void                 adjustOutputParmsForNamedInputChange(
                                            const OP_ConnectorId& input_name,
                                            bool inputnull);
    void                 swapInputs(int srcidx, int dstidx);

    void                 addDiagnosticInfo(
                                const VCC_DiagnosticInfo &diag) override;

    int                  getShaderExtraParametersHelper(
                                         UT_Array<VOP_Type> &types,
                                         UT_IntArray &doexport,
                                         UT_StringArray &names,
                                         UT_StringArray &raw_names,
                                         UT_StringArray &def,
                                         VOP_Type shader_type = VOP_TYPE_UNDEF )
                                                const;
private:
    void                 getBaseOutputName(UT_String &out, int idx) const;
    int                  NUMPARMS() const;
    bool                 VEX_STRICT() const;
    bool                 FORCECODEGENERATION() const;
    bool                 STRICTVARIABLES() const;
    void                 OUTPUTNAME(UT_String &str, int idx, bool expand) const;
    CH_StringMeaning     OUTPUTNAMEmeaning(int idx) const;
    void                 setOutputParm(UT_String &str, CH_StringMeaning meaning,
                                       int idx);
    void                 OUTPUTLABEL(UT_String &str, int idx) const;
    void                 EXPORTLIST(UT_StringHolder &str) const;
    void                 getFunctionName(UT_String &fname) const;

    void                 evaluateCode(UT_StringHolder &codestr) const;
    void                 cppStripCode(UT_StringHolder &codestr) const;
    static bool          adjustColumnForBindings(const char *l, int &col, bool strict_varnames);

    bool                 mySearchingForInputs;
};

#endif