SHOP/SHOP_Node.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        SHOP_Node.h ( SHOP Library, C++)
 *
 * COMMENTS:    Shader OPs.  These are nodes which collect all shading
 *              information for nodes into a nice compact encapsulation.
 */

#ifndef __SHOP_Node__
#define __SHOP_Node__

#include "SHOP_API.h"
#include <UT/UT_HashTable.h>
#include <IMG/IMG_Raster.h>
#include <OP/OP_Network.h>
#include "SHOP_Error.h"

class UT_Options;
class OP_OperatorTable;
class OP_TemplatePair;
class OP_OperatorTable;
class SHOP_Data;
class SHOP_ReData;
class SHOP_Node;
class SHOP_Clerk;
class SHOP_ClerkCacheEntry;
class SHOP_BundleRef;

extern "C" {
    SYS_VISIBILITY_EXPORT extern void   newShopClerk();
}

// Sub-class variables should start their local variables at SHOP_VAR_MAX_BASE
enum {
    SHOP_VAR_OBJ = 0,
    SHOP_VAR_SOP,
    SHOP_VAR_MAX_BASE
};

#include "SHOP_NodeTypes.h"

#define SHOP_RENDERTYPE_OPTION      "rendertype"
#define SHOP_FPRECISION_OPTION      "soho_precision"

class SHOP_API SHOP_Node : public OP_Network {
public:
             SHOP_Node(OP_Network *dad, const char *name,
                       OP_Operator *entry, SHOP_TYPE shader_type=SHOP_SURFACE);
    virtual ~SHOP_Node();

    static OP_VariablePair      myVariablePair;
    static CH_LocalVariable     myVariableList[];

    static PRM_Template *getObsolete(SHOP_TYPE type);
    static const char   *getShaderType(SHOP_TYPE type);
    static const char   *getShaderLabel(SHOP_TYPE type);
    static const char   *getIconName(SHOP_TYPE type);
    static const char   *getBundleFilter(SHOP_TYPE type);
    static const char   *getShaderParmPath(SHOP_TYPE type);
    static const char   *getShaderSpaceParm(SHOP_TYPE type);
    static SHOP_TYPE     getShaderType(const char *name);
    static SHOP_TYPE     getTypeFromParm(const char *parmname);
    static SHOP_TYPE     getTypeFromSpaceParm(const char *parmname);

    // Convert a string like "{'foo':'bar','fum':(1,2,3)}' to a UT_Options
    static bool          convertStringToOptions(UT_Options &options,
                                                const char *str);

    static bool          isParmDefaultValue(OP_Node *node,
                                            PRM_Parm *parm,
                                            fpreal64 now,
                                            const UT_Options *options);
    static bool          isParmDefaultValue(OP_Node *node,
                                            const char *parmname,
                                            fpreal64 now,
                                            const UT_Options *options);

    const UT_String     &getRenderMask() const  { return myRenderMask; }

    virtual int          getFirstParameter();
    virtual int          getLastParameter();

    virtual bool         runCreateScript();

    // The options may contain:
    //  rendertype:  The the shader for a specific renderer
    virtual SHOP_Node   *findShader(SHOP_TYPE shop_type, fpreal64 now,
                                    const UT_Options *options);

    /// Returns true if the shop node provides a shader for a given shop_type.
    virtual bool         matchesShaderType(SHOP_TYPE shop_type);

    // Collect all shaders of the specific type which are hooked up.
    // The return code is the number of shaders in the list.
    virtual int          collectShaders(UT_PtrArray<SHOP_Node *>&list,
                                    SHOP_TYPE shop_type, fpreal64 now,
                                    const UT_Options *options);

    virtual int          getInputTileLOD() const;
    virtual int          getOutputTileLOD() const;
    virtual bool         isInputVisible(int idx) const;
    virtual bool         isOutputVisible(int idx) const;

    virtual bool         getBoundingBox(UT_BoundingBox &box, OP_Context &ctx)
                            { return OP_Network::getBoundingBox(box, ctx); }
    virtual bool         getBoundingBox(UT_BoundingBox &box, OP_Context &ctx,
                                        const char *rtype);

    virtual SHOP_Node   *getOutputNode() const;
    virtual void         getInputName(UT_String &name, int idx) const;
    virtual SHOP_TYPE    getInputType(int idx) const;
    virtual void         getOutputName(UT_String &name, int idx) const;
    virtual SHOP_TYPE    getOutputType(int idx) const;

    virtual void         saveDialogScriptExtraInfo(ostream &os);
    virtual void         createGalleryEntry(OP_GalleryEntry &entry);

    // Get a list of available clerks for this operator.  It is very good
    // practice not to manipulate this list...
    static UT_PtrArray<SHOP_Clerk *>    &getClerkList(SHOP_TYPE type);

    // This is only called from a Clerk to find out the shader name (when
    // building the render data). Note that the returned pointer may become
    // invalidated, so make a copy of the data if it must be kept around.
    virtual const char  *getShaderName(bool forvex, SHOP_TYPE shop_type) const;
    virtual void         getVariableString(int idx, UT_String &str, int thread);

    virtual bool         createSpareParametersFromChannels(
                                    UT_BitArray &selection,
                                    const CH_ChannelList &channels);
    virtual bool         createSpareParametersForLoad(
                                    UT_StringArray &names,
                                    PRM_ParmNameMap &nmap,
                                    UT_String &errors);

    // For the local variables to work properly, please set the caller OP
    // before evaluating the render data (or geometry strings).  This should be
    // set to the object being evaluated, not the SOP.
    OP_Node             *getCallingOBJ()                { return myCallingOBJ; }
    void                 setCallingOBJ(OP_Node *o)      { myCallingOBJ = o; }
    OP_Node             *getCallingSOP()                { return myCallingSOP; }
    void                 setCallingSOP(OP_Node *s)      { myCallingSOP = s; }

    /// Obtain a clerk that matches the shop type of this node and the render
    /// type. If the shop type of this node is multi-type, then the method
    /// argument is used to interpret the multi type as a specific shop type,
    /// which is then used to match the clerk.
    SHOP_Clerk          *getClerk(const char *rendertype,
                                  SHOP_TYPE interpret_type = SHOP_INVALID );
    SHOP_Clerk          *getAnyClerk(bool only_string_generators);

    virtual bool         buildShaderString(UT_String &result, fpreal64 now,
                                    const UT_Options *options,
                                    OP_Node *obj=0, OP_Node *sop=0,
                                    SHOP_TYPE interpret_type = SHOP_INVALID);
    virtual bool         buildShaderData(SHOP_ReData &data, fpreal64 now,
                                    const UT_Options *options,
                                    OP_Node *obj=0, OP_Node *sop=0,
                                    SHOP_TYPE interpret_type = SHOP_INVALID);
    virtual bool         buildShaderBounds(UT_BoundingBox &box, fpreal64 now,
                                    const UT_Options *options,
                                    OP_Node *obj=0, OP_Node *sop=0,
                                    SHOP_TYPE interpret_type = SHOP_INVALID);

    /// Build a shader string for a VOP node.  If the VOP isn't a code creator,
    /// the code creator parent of the VOP will have its string generated.
    virtual bool        buildVopShaderString(VOP_Node *vop,
                                    UT_String &result, fpreal64 now,
                                    const UT_Options *options,
                                    OP_Node *obj, OP_Node *sop,
                                    SHOP_TYPE interpret_type = SHOP_INVALID);

    /// Get the shader name assocaited with a VOP
    bool                getVopShaderName(OP_Node *node,
                                UT_WorkBuffer &name,
                                bool forvex, SHOP_TYPE shop_type) const;

    void                  destroyCache();
    SHOP_ClerkCacheEntry *getClerkData(const SHOP_Clerk *clerk);
    void                  destroyClerkData(const SHOP_Clerk *clerk);
    void                  addClerkData(const SHOP_Clerk *clerk,
                                        SHOP_ClerkCacheEntry *entry);

    virtual SHOP_TYPE    getShaderType() const;

    /// Returns the shader types this shop outputs.
    virtual void         getOutputShaderTypes(UT_RefArray<SHOP_TYPE> & types);

    static bool          addShaderClerk(SHOP_TYPE type, SHOP_Clerk *shop);
    static void          buildShaderTable(OP_OperatorTable &table);
    static OP_Operator  *getManagementOperator();

    // Scan properties SHOPs searching for the parameter specified.  If the
    // parameter is found, the opid of the SHOP is returned along with the
    // parameter index for the parameter.
    bool                 findPropertiesParameter(const char *parm, fpreal64 now,
                                                int &opid, int &pidx);

    // Convenience error methods
    void         addError(int code, const char *msg = 0)
                 { UTaddError("SHOP", code, msg);}
    void         addMessage(SHOP_ErrorCode code, const char *msg = 0)
                 { UTaddMessage("SHOP", code, msg);}
    void         addWarning(SHOP_ErrorCode code, const char *msg = 0)
                 { UTaddWarning("SHOP", code, msg);}
    void         addFatal(SHOP_ErrorCode code, const char *msg = 0)
                 { UTaddFatal("SHOP", code, msg);}
    void         addSystemError(const char *msg = 0)
                 { UTaddSystemError(msg);}
    void         addCommonError(UT_CommonErrorCode what, const char *msg = 0)
                 { UTaddCommonError(what, msg);}

    int          getOGLTextureCount() const     { return myOGLTextureCount; }
    void         bumpOGLTextureCount(int dir)   { myOGLTextureCount += dir; }

    bool         containsShopType(SHOP_TYPE type) const;
    void         bumpContainedType(SHOP_TYPE type, int dir);

    int          getOGLScriptCacheState() const { return myOGLScriptCache; }
    void         setOGLScriptCache(int val, 
                                   const char *vtxsrc, const char *fragsrc) 
                                { myOGLScriptCache = val;
                                  myOGLVtxSource.harden(vtxsrc);
                                  myOGLFragSource.harden(fragsrc);
                                }
    const char  *getOGLVtxSource() const 
                                { return (const char *) myOGLVtxSource; }
    const char  *getOGLFragSource() const 
                                { return (const char *) myOGLFragSource; }

    //
    // The following evaluator will evaluate the string parameter.  However, it
    // will also perform any bundle pattern expansion, or matrix evaluation
    // based on the PRM_SpareData.
    // The quoted bool returns whether the result should be considered to be a
    // string (or whether it's another data type).
    //
    void                 evalStringParm(UT_String &result,
                                        const char *parm_name,
                                        int vector_index, fpreal64 now,
                                        const PRM_Template *tplate,
                                        bool &quoted,
                                        const char *rtype, int fprecision);

    // Standard OP Network methods
    virtual const char  *getChildType() const;
    virtual const char  *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;

    // Absolute Width
    virtual fpreal       getW() const;
    // Absolute Height
    virtual fpreal       getH() const;  

    static void          initializeExpressions();

    // SHOP Parameter Evaluation with options.
    bool                 evalShopParameter(const char *name, int vec_idx,
                                            fpreal64 now, int &value,
                                            const UT_Options *options,
                                            bool add_cook_dependency=false);
    bool                 evalShopParameter(const char *name, int vec_idx,
                                            fpreal64 now, fpreal &value,
                                            const UT_Options *options,
                                            bool add_cook_dependency=false);
    bool                 evalShopParameter(const char *name, int vec_idx,
                                            fpreal64 now, UT_String &value,
                                            const UT_Options *options,
                                            bool add_cook_dependency=false);

    // Overrides of OP_Node methods specific to materials 
    virtual UT_String   *getMaterialIconFilename()
                         { return &myMaterialIconFilename; }
    virtual void         setMaterialIconFilename(const char *icon_file)
                         { myMaterialIconFilename.harden(icon_file); }

    virtual IMG_Raster  *getMaterialIconImage()
                         { return &myMaterialIconImage; }

    virtual bool         getMaterialIconAllowRegenerateFlag() 
                         { return myAllowIconRegeneration; }
    virtual void         setMaterialIconAllowRegenerateFlag(bool allow) 
                         { myAllowIconRegeneration = allow; }

    /// Returns a procedural shader node of a given type, if the shop
    /// indeed has such a node. Returns NULL otherwise.
    virtual VOP_Node *  getProcedural(VOP_Type type);

    /// Method that is invoked when the HDA index file has been cleared
    /// because the underlying HDA definition has changed.
    virtual void        handleOTLIndexFileCleared()
                        {}

protected:
    virtual void         changeParmTemplate(PRM_Template *new_template);

    // Standard OP Node methods
    virtual int          getDataClass() const;
    virtual OP_ERROR     cookMe(OP_Context &);
    virtual OP_ERROR     bypassMe(OP_Context &, int &);
    virtual const char  *getFileExtension(int binary) const;

    virtual OP_DATA_TYPE getCookedDataType() const;
    virtual void         deleteCookedData();
    virtual int          saveCookedData(const char *, OP_Context &);
    virtual int          saveCookedData(ostream &, OP_Context &, int);

    virtual bool         cookedDataUsesAllParameters() const
                         { return true; }
    virtual bool         cookedDataNeedsErrors() const
                         { return true; }

    // This method will expand the pattern specified, possibly generating a
    // bundle for expansion.
    void                 resolveParmBundle(const char *parm_name,
                                           int vector_index, 
                                           UT_String &pattern,
                                           OP_Network *creator,
                                           const char *filter,
                                           bool expand_fullpath = false);

    // Instead of simply getting the node wired into the input specified, we
    // also get the output number which it's wired from.
    SHOP_Node           *getFullInput(int input_idx, int &output_idx) const;

    void                 setShaderType(SHOP_TYPE t);

    /// Checks if the options specify a render mask that limit
    /// the types of nodes that can be returned by findShader().
    /// Returns this object if no clerk name is specified or if
    /// the node maches the specified clerk. Otherwise, returns NULL.
    SHOP_Node *          checkRenderMask( const UT_Options *options);

    bool                 renderMatch(const char *rendertype) const;
    bool                 renderMatch(const SHOP_Clerk &clerk) const;

    int                          myContainedShops[SHOP_MAX_TYPES];
    UT_String                    myRenderMask;
    UT_HashTable                 myClerkCache;
    OP_Node                     *myCallingOBJ, *myCallingSOP;
    int                          myOGLTextureCount;
    int                          myOGLScriptCache;
    UT_String                    myOGLVtxSource, myOGLFragSource;

    UT_String                    myMaterialIconFilename;
    IMG_Raster                   myMaterialIconImage;
    bool                         myAllowIconRegeneration; 

private:
    static void                  installClerks();
    static void                  installCommands();

    SHOP_TYPE                    myShaderType;
};

// Function to get a list of template arrays containing parm names that must
// be reserved when compiling VEX SHOPs.
SHOP_API extern void
SHOPgetVexReservedTemplateLists(UT_PtrArray<PRM_Template *> &tplatelists);

#endif

---