VOP/VOP_CodeGenerator.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.
 *
 * Produced by:
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 */

#ifndef __VOP_CodeGenerator_h__
#define __VOP_CodeGenerator_h__

#include "VOP_API.h"
#include <OP/OP_Network.h>
#include "VOP_Error.h"
#include "VOP_Node.h"

// The names of the parameters for setting the min and max inputs for the
// operator type defined by a VOP Network.
#define VOP_MININPUTS_NAME      "mininputs"
#define VOP_MAXINPUTS_NAME      "maxinputs"

class UT_IStream;
class UT_WorkArgs;
class UT_StringArray;
class CH_LocalVariable;
class OP_OTLDefinition;
class VOP_Node;
class VOP_Language;
class VOP_CodeGenerator;
class VOP_CodeVarMapper;
class VOP_CodeVarLookupData;
class VOP_CodeCompilerArgs;

class VOP_API VOP_CodeParm
{
public:
    typedef enum {
        ENDGROUP,
        STARTGROUP,
        ENTRY
    } VOP_CodeParmType;

    VOP_CodeParm()
        : myType(ENDGROUP), myOp(0) { }
    VOP_CodeParm(const char *groupname)
        : myType(STARTGROUP), myName(groupname, 1), myOp(0) { }
    VOP_CodeParm(VOP_Node *vop)
        : myType(ENTRY), myOp(vop) { }
    VOP_CodeParm(const VOP_CodeParm &src)
        : myType(src.myType), myName(src.myName, 1), myOp(src.myOp) { }

    VOP_CodeParmType     getType() const
                         { return myType; }
    const char          *getName() const
                         { return myName; }
    void                 setName(const char *name)
                         { myName.harden(name); }
    VOP_Node            *getOp() const
                         { return myOp; }

    bool                 operator==(const VOP_CodeParm &)
                         { return false; }
    const VOP_CodeParm  &operator=(const VOP_CodeParm &src)
                         {
                             myType = src.myType;
                             myName.harden(src.myName);
                             myOp = src.myOp;
                             return *this;
                         }

private:
    VOP_CodeParmType     myType;
    UT_String            myName;
    VOP_Node            *myOp;
};

class VOP_CodeParmList
{
public:
                         VOP_CodeParmList()
                         { }
                        ~VOP_CodeParmList()
                         { }

    void                 append(const VOP_CodeParm &parm)
                         {
                             myParms.append(parm);
                             myParmNodes.addSymbol(UT_Hash_Ptr(parm.getOp()),
                                                   UT_Thing());
                         }
    void                 insert(const VOP_CodeParm &parm, int idx)
                         {
                             myParms.insert(parm, idx);
                             myParmNodes.addSymbol(UT_Hash_Ptr(parm.getOp()),
                                                   UT_Thing());
                         }
    void                 move(int first, int last, int newpos)
                         {
                             myParms.move(first, last, newpos);
                         }
    void                 remove(int idx)
                         {
                             const VOP_Node     *vop;

                             vop = myParms(idx).getOp();
                             myParms.remove(idx);
                             myParmNodes.deleteSymbol(UT_Hash_Ptr(vop));
                         }
    void                 clear()
                         {
                             myParms.entries(0);
                             myParmNodes.clear();
                         }

    const VOP_CodeParm  &operator()(int idx) const
                         {
                             return myParms(idx);
                         }
    VOP_CodeParm        &operator()(int idx)
                         {
                             return myParms(idx);
                         }
    int                  entries() const
                         {
                             return myParms.entries();
                         }
    bool                 hasNode(const VOP_Node *node) const
                         {
                             UT_Thing    thing;

                             return myParmNodes.findSymbol(UT_Hash_Ptr(node),
                                                           &thing) != 0;
                         }

private:
    UT_RefArray<VOP_CodeParm>            myParms;
    UT_HashTable                         myParmNodes;
};

class VOP_API VOP_CodeOperatorFilter : public OP_OperatorFilter
{
public:
    VOP_CodeOperatorFilter(const char *optypename, VOP_CodeGenerator *owner);
    virtual ~VOP_CodeOperatorFilter();

    virtual bool         allowOperatorAsChild(OP_Operator *op);

private:
    UT_String            myVopnetType;
    VOP_CodeGenerator   *myOwner;
};

class VOP_API VOP_CodeGenerator
{
public:
                         VOP_CodeGenerator(OP_Network *owner,
                                           VEX_ContextType vextype,
                                           RSL_ContextType rsltype,
                                           int mininputs,
                                           int maxinputs);
    virtual             ~VOP_CodeGenerator(void);

    OP_OperatorFilter   *getOperatorFilter();
    UT_ErrorManager     &getErrorManager();

    void                 beforeAddNode(OP_Node *node);
    void                 afterAddNode(OP_Node *node);
    void                 appendCompileErrors(UT_WorkBuffer &text,
                                             int verbose, bool addseparator);

    void                 ownerChanged(OP_EventType reason, void *data);
    void                 ownerFinishedLoadingNetwork();
    void                 generateVopErrors();
    void                 updateExportedParameters();
    bool                 getVariableString(int index, UT_String &value);

    const char          *getEnglishName();
    /// @{
    /// The function name is mangled for some renderers (i.e. RSL) since basing
    /// the function name on the node name is not safe.  However, some places
    /// require the node name -- unmangled (i.e. dialog scripts).
    const char          *getFunctionName(UT_WorkBuffer &storage) const;
    const char          *getInternalFunctionName(UT_WorkBuffer &storage) const;
    /// @}
    /// The function path is the leading path to the shader
    const char          *getFunctionPath(UT_WorkBuffer &storage) const;
    int                  getMinimumInputs() const;
    int                  getMaximumInputs() const;
    void                 getInternalOperatorInfo(OP_OTLDefinition &info);
    void                 getInternalScriptDefinition(UT_String &definition);

    void                 setVexCodeDirty();
    void                 outputVexCode(ostream &os, const char *shadername);
    void                 outputVflCode(ostream &os, const char *shadername,
                                       bool skipheader = false);

    void                 generateRslObject(UT_String &ofile,
                                           const char *cache_directory,
                                           const char *renderer,
                                           int major_version,
                                           int minor_version,
                                           const char *shaderpath,
                                           const char *shadername,
                                           bool ignore_dirty_flag,
                                           UT_String *error_return);

    // Get a list of all Parameter type VOPs.
    void                 getParameterNodes(VOP_CodeParmList &list,
                                           bool includeInvisible);

    // Returns our owner's output node if it has one.
    OP_Node             *getOutputNode() const;

    // Expand the compiler & options using local variables.
    const char          *getCompiler(UT_String &compiler, fpreal now,
                                     const char *defcompiler);
    const char          *getCompiler(UT_WorkBuffer &wbuf, fpreal now,
                                     const char *defcompiler);

    // Get a string containing the errors from our last compile.
    const UT_String     &getCompilerErrors() const
                         { return myCachedErrorMessages; }

    // Get the VOP language generated by this code.
    const VOP_Language  *getLanguage() const
                         { return myLanguage; }
    VEX_ContextType      getVexContextType() const
                         { return myVexContextType; }
    RSL_ContextType      getRslContextType() const
                         { return myRslContextType; }
    VOP_CodeCompilerArgs*getCompilerArgs()
                         { return myCompilerArgs; }

    // Functions to set the locked compiled code and dialog script. When
    // set, these values cause us to ignore our VOP nodes and always
    // return these locked values.
    void                 setLockedCompiledCode(const char *code);
    void                 setLockedCompiledDs(const char *ds);

    // The local variables that must be defined by any code generator node.
    // These are the variables understood by the getVariableString function
    static CH_LocalVariable      theLocalVariables[];

    // Install commands specific to VOP code generators.
    static void                  installCommands();

    // This function converts a local VOP code generator to a global VOP code
    // generator that defines an operator type.
    static bool                  convertVopOpToVopOpType(OP_Node *node,
                                                         UT_String &err);

    // These variables define the parameter descriptions for the VOP
    // compiler parm used to specify how to compile VOP generated code.
    static PRM_Name              theVopCompilerName;
    static PRM_Default           theVopCompilerVexDefault;
    static PRM_Default           theVopCompilerRslDefault;
    static PRM_ChoiceList        theVopCompilerChoices;
    static PRM_Name              theVopForceCompileName;

    static bool                  forceCompile(OP_Node *node);
    static int                   forceCompile(void *data, int, float,
                                              const PRM_Template *);

private:
    void                 deleteAutoConvertNodesIn(VOP_NodeList& nodes);
    void                 outputBodyCodeWithIndents(ostream &os,
                                        UT_WorkBuffer &code);
    void                 outputVflPragmas(ostream &os);
    void                 outputVflFunctionDeclaration(ostream &os,
                                                const char *shadername);
    bool                 outputVflFunctionBlock(ostream &os,
                                                const char *shadername);
    void                 outputChildrenParameterBlocks(OP_Network *net,
                                                ostream &os);
    void                 outputParameterDeclarations(ostream &os,
                                                const char *indent);
    void                 generateScriptDefinition(UT_String &definition);
    void                 getParameterNodes(OP_Network *net,
                                           VOP_CodeParmList &list,
                                           ostream *os,
                                           bool includeInvisible);
    void                 getParameterNodes(VOP_CodeParmList &list,
                                           ostream *os,
                                           bool includeInvisible);
    void                 assignSubnetInOutVariables(VOP_Node *node,
                                        VOP_Node *subnet,
                                        UT_SymbolTable &localVarTables,
                                        VOP_CodeVarLookupData &data) const;

    // These functions are used for resolving variable names.
    static const char   *createUniqueVariableName(const char *str,
                                                  UT_SymbolTable &varTable);
    static const char   *doVariableReplacement(const char *str,
                                               void *userdata);
    void                 addVariableNames(VOP_Node *vop,
                                          UT_SymbolTable &varTable,
                                          VOP_CodeVarMapper &varMapper);

    void                 makeTempFileName();

    OP_Network                  *myOwner;
    UT_WorkBuffer                myLockedCompiledCode;
    UT_WorkBuffer                myLockedCompiledDs;
    VEX_ContextType              myVexContextType;
    RSL_ContextType              myRslContextType;
    UT_SymbolTable               myGlobalVariables;
    UT_SymbolTable               myLocalVariables;
    UT_SymbolTable               myLocalChannels;
    VOP_CodeOperatorFilter       myOperatorFilter;
    VOP_Language                *myLanguage;
    VOP_CodeCompilerArgs        *myCompilerArgs;
    UT_ErrorManager              myErrorManager;
    UT_String                    myCachedEnglishName;
    UT_String                    myCachedDialogScript;
    UT_String                    myCachedVexCode;
    UT_String                    myTempVflFileName;
    UT_String                    myTempErrFileName;
    UT_String                    myCachedErrorMessages;
    bool                         myCachedVexCodeDirty;
    int                          myCachedMinInputs;
    int                          myCachedMaxInputs;
    int                          myMinimumNumberOfInputs;
    int                          myMaximumNumberOfInputs;
    mutable int                  myOutputNodeId;
};

class VOP_CodeGeneratorErrorThief
{
public:
                 VOP_CodeGeneratorErrorThief(OP_Node &node)
                     : myNode(node)
                 {
                 }
                ~VOP_CodeGeneratorErrorThief()
                 {
                     if( myNode.getVopCodeGenerator() )
                     {
                         myNode.stealErrors(
                                myNode.getVopCodeGenerator()->getErrorManager(),
                                true);
                     }
                 }

private:
    OP_Node     &myNode;
};

#endif

---