VOP_Visualize.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_Visualize_h__
#define __VOP_Visualize_h__

#include "VOP_API.h"
#include "VOP_ParameterBase.h"

class PI_EditScriptedParm;

class VOP_API VOP_Visualize : public VOP_ParameterBase
{
public:
    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);
    static PRM_Template         *buildTemplates(const VOP_Language *language);
    void                         getCode(UT_String &codestr,
                                         const VOP_CodeGenContext &context
                                         ) override;

    void                         initializeNode() override;

    bool forceCodeGenerationOfInputs( const VOP_CodeGenContext &ctx, 
                                      bool check_shader_context) const override
    {
        if (!getInput(0))
            return false;
        return VOP_ParameterBase::forceCodeGenerationOfInputs(ctx, 
                check_shader_context);
    }

    bool                         getIsParmGenerator() const override
    { if (!getInput(0)) return false;
      return VOP_ParameterBase::getIsParmGenerator(); }

    // Because we switch in and out of being an op generator we
    // have to dirty the parm generator explicitly on a rewire.
    void                         opChanged(OP_EventType reason,
                                           void *data=0) override;

    // Get the parm block information that will go in the dialog script
    // for our VOPNET.
    void                         getParameterDeclaration(
                                        UT_String &parmdecl,
                                        const VOP_Language *language,
                                        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;

    const char                  *inputLabel(unsigned idx) const override;

    void                         setPARMNAME(const UT_String &str) override;
    void                         setPARMLABEL(const UT_String &str);
    void                         setPARMTYPEINDEX(int type) override;
    void                         setPARMSTORAGE(int type) override;
    void                         setPARMSTRINGTYPE(const char *style);
    void                         setPARMOPFILTER(const char *filter);

    void                         PARMNAME(UT_String &str) const override;
    void                         PARMPREFIX(UT_String &str) const override;
    void                         PARMPOSTFIX(UT_String &str) const override;
    void                         PARMLABEL(UT_String &str) const override;
    int                          PARMTYPEINDEX() const override;

    bool                         isParmVisible() const override;
    void                         copySettingsFrom(
                                    VOP_ParmGenerator *pvop) override;
    void                         copyDefaultValuesFrom(
                                    const PI_EditScriptedParm *parm) override;

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

    bool                         updateParmsFlags() override;
    
    // Override cook method just so we can set our warnings properly.
    bool                         USEASPARMDEFINER() const override;
    int                          UNIFORM() const override;
    int                          USEBOUND() const override;
    int                          EXPORTPARM() const override;
    void                         EXPORTSHADERCONTEXTS(
                                        UT_StringArray &context_names
                                        ) const override;
    using VOP_ParameterBase::EXPORTSHADERCONTEXTS;
    void                         MENUCHOICES(UT_String &str) const override;
    void                         CALLBACKSTR(UT_String &str) const;
    void                         HELPTEXTSTR(UT_String &str) const;
    int                          INVISIBLE() const;
    int                          JOINNEXT() const;
    int                          SHOWLABEL() const;
    int                          IRANGE(int index) const;
    float                        FRANGE(int index) const;

    bool                         needsInput() override;

    // Build the code to be output when useBound() is true but the parameter
    // is not actually bound:
    void                         getUnboundCode(UT_String &codestr,
                                    const VOP_CodeGenContext &context) override;

    void                         getParmDeclarationCode(
                                    UT_String &parm_decl,
                                    const VOP_CodeGenContext &codegen_ctx,
                                    const VOP_Language *language=NULL,
                                    bool export_parms=false) override;

    // Determines based on the parm index if the PARMNAME may be changed
    // when this parm is changed.
    bool                         getParmCanAffectParmName(
                                        int pidx) const override;

    void                         getInputTypeInfoSubclass(
                                        VOP_TypeInfo &type_info,
                                        int idx) override;
    void                         getOutputTypeInfoSubclass(
                                        VOP_TypeInfo &type_info, 
                                        int idx) override;
private:
    bool                         allowMenu(int parmtype) const;

    // Store the index of the Visualize Name and Parameter Type parameters.
    static int                   theParmNameParmIndex;
    static int                   theParmTypeParmIndex;
};

#endif