ROP/ROP_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:
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        ROP Library (C++)
 *
 * COMMENTS:    The base class for all Render Operators
 *
 */

#ifndef __ROP_Node_h__
#define __ROP_Node_h__

#include "ROP_API.h"
#include <OP/OP_Network.h>

class OP_OperatorTable;
class OP_TemplatePair;
class IMG_Raster;
class UT_FloatArray;
class UT_Interrupt;
class UT_IStream;
class UT_DMatrix4;

class ROP_Node;
class ROP_ExecuteContext;
class ROP_IFD;
class ROP_IFDBase;
class ROP_SohoOp;
class ROP_RenderCmdParms;
class ROP_RenderItem;
class ROP_RenderList;
class ROP_RenderDepParms;
class GU_DetailHandle;
class TAKE_Take;

extern "C" {
    DLLEXPORT extern void       newDriverOperator(OP_OperatorTable *table);
};

typedef enum {
    ROP_ABORT_RENDER = 0,       // Stop rendering
    ROP_CONTINUE_RENDER = 1,    // Go on to the next frame
    ROP_RETRY_RENDER = 2        // Retry this frame (primarily for network)
} ROP_RENDER_CODE;

typedef void    (*ROP_ExecuteOverride)(ROP_Node *me, float time, void *data);

#define FLT_PARM(name, idx, vi, t)      \
                { return evalFloat(name, vi, t); }
#define FLT_SET(name, idx, vi, t, val)  \
                { setFloat(name, vi, t, val); }
#define INT_SET(name, idx, vi, t, val)  \
                { setInt(name, vi, t, val); }

#define INT_PARM(name, idx, vi, t) \
                { return evalInt(name, vi, t); }

#define INT_SET(name, idx, vi, t, val) \
                { setInt(name, vi, t, val); }

#define STR_PARM(name, idx, vi, t) \
                { evalString(str, name, vi, (float)t); }

//___________________________________________________________________________

class ROP_SohoOutput;
class SOHO_IPRList;

class ROP_API ROP_Node : public OP_Network
{
public:
    // Standard OP_Network stuff:
    virtual const char  *getChildType() const;
    virtual const char  *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;
        
    //  Nobody should have to override this, but it's public for other people

    virtual unsigned     disableParms();
    virtual OP_DATA_TYPE getCookedDataType() const;
    virtual void        *getCookedData(OP_Context &context);

    // The castToROPIFD() method returns a pointer to an IFD node or NULL
    // if the ROP is not an IFD ROP.  If a pointer is returned it may be
    // a representative node, and care must be taken to not confuse the
    // returned node with the node on which the method was called.
    // TODO: check places that store the return of this function.
    virtual ROP_IFD     *castToROPIFD();
    virtual ROP_IFDBase *castToROPIFDBase();
    virtual ROP_SohoOp  *castToROPSoho();

    virtual bool         hasImageOutput();

    static void          buildOperatorTable(OP_OperatorTable &table);
    static OP_Operator  *getManagementOperator();
    static OP_Operator  *getCOP2ManagementOperator();
    static OP_Operator  *getDOPManagementOperator();
    static OP_Operator  *getSOPManagementOperator();
    static void          buildGameOperatorTable(OP_OperatorTable &table);
    static void          initSimulationOPs();
    //
    // The following method will return 1 if the raster was successfully
    //  generated.  Otherwise, it will return 0.
    //  If the OP is incapable of generating a raster, an error will be
    //  generated.
    int                  renderFile(OP_Context &ctx, float aspect,
                                    const char *file);

    virtual void         getFrameRange(long &s, long &e);

    OP_ERROR             execute(float now, ostream *verbose=0);
    OP_ERROR             executeSingle(float time,
                                       ostream *verbose=0,
                                       SOHO_IPRList *ipr=0,
                                       ROP_SohoOutput *out=0,
                                       bool generate=false);

    // Execute full will perform a render for the viewport or render menu.
    //  1) If not a sequence render, force background rendering
    //  2) Call the render manager to execute the render network
    //  3) Restore things
    OP_ERROR             executeFull(fpreal now, bool sequence = false);

    // These calling mechanisms allow us to start an execute, then call
    // nextExecute() on our own time, finishing with endExecute().  This allows
    // callers to do things between renders...
    ROP_ExecuteContext  *getExecuteContext() { return myEContext; }
    void                 setExecuteContext(ROP_ExecuteContext *c)
                         { myEContext = c; }

    void                 setExecuteOverride(ROP_ExecuteOverride f, void *d)
                         { myExecuteOverride = f;
                           myExecuteOverrideData = d;
                         }
    void                 setPreExecuteOverride(ROP_ExecuteOverride f, void *d)
                         { myPreExecuteOverride = f;
                           myPreExecuteOverrideData = d;
                         }
    void                 setPostExecuteOverride(ROP_ExecuteOverride f, void *d)
                         { myPostExecuteOverride = f;
                           myPostExecuteOverrideData = d;
                         }
    OP_ERROR             startExecute(float now, ostream *verbose = 0);
    OP_ERROR             nextExecute(int &again);
    OP_ERROR             endExecute(int &again);

    typedef enum { RENDER_PRM, RENDER_GETRASTER } ROP_RenderMode;
    void                         setRenderMode(ROP_RenderMode);
    ROP_RenderMode               getRenderMode();

    void                         setRenderOutput(UT_String &);
    UT_String                   &getRenderOutput();
    UT_String                   &getRenderDevice();
    UT_String                   &getRenderSuffix();
    void                         setRenderResX(int x);
    void                         setRenderResY(int y);
    int                          getRenderResX();
    int                          getRenderResY();
    void                         setRenderAspect(float aspect);
    float                        getRenderAspect();

    // The following methods have to be public for Remote
    virtual void                 SETDORANGE(int val)
                                 { INT_SET("trange", 0, 0, 0, val) }
    virtual int                  DORANGE()
                                 { if(myOverrideFrameRangeFlag)
                                     return 1;
                                   INT_PARM("trange", 0, 0, 0) }

    virtual float       FSTART()
                { if(myOverrideFrameRangeFlag)
                    return myOverrideStartFrame;
                  FLT_PARM("f", 1, 0, 0) }
    virtual float       FEND()
                { if(myOverrideFrameRangeFlag)
                    return myOverrideEndFrame;
                  FLT_PARM("f", 1, 1, 0) }

    virtual float       FINC()
                { if(myOverrideFrameRangeFlag)
                    return myOverrideFrameInc;
                  return evalFloat("f", 2, 0); }

    
    static int                   doRenderCback(void *data, int index,
                                               float time,
                                               const PRM_Template *);

    static int                   doRenderDialog(void *data, int index,
                                                float time,
                                                const PRM_Template *);

    static PRM_Template         *getROPbaseTemplate();
    static PRM_Template         *getROPscriptTemplate();
    static OP_TemplatePair      *getROPcopTemplate();
    static OP_TemplatePair      *getROPcop2Template();
    static OP_TemplatePair      *getROPcodeTemplate();
    static OP_TemplatePair      *getROPcodedataTemplate();
    static CH_LocalVariable      myVariableList[];
   
    bool                         executePreRenderScript(float ttime);
    bool                         executePreFrameScript(float ttime);
    bool                         executePostFrameScript(float ttime);
    bool                         executePostRenderScript(float ttime);

    static void          buildRibVersionMenu(PRM_Name *menu, int max,
                                             bool for_archive=false);

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

    // This adds render items to a ordered list. The list is traversed from
    // 1 -> entries to render. 
    virtual void         buildRenderDependencies(const ROP_RenderDepParms &p);

    static void          setDependencyRenderFlag(bool f);
    static bool          getDependencyRenderFlag();

    static void          setFrameByFrameFlag(bool f);
    static bool          getFrameByFrameFlag();

    static void          setRenderScriptFlag(bool enable);
    static bool          getRenderScriptFlag();


    static void          setOutputResolutionScale(fpreal xscale,fpreal yscale);
    static void          getOutputResolutionScale(fpreal &xs,   fpreal &ys);

    virtual void         getOutputResolution(int & /*x*/, int & /*y*/) { }
    virtual void         getOutputFile(UT_String & /*name*/) { }

    // three levels - 0 = low/fastest, 1 = med/fast, 2 = normal
    static void          setRenderQuality(int quality);
    int                  getRenderQuality();

    void                 overrideFrameRange(bool enable,
                                            float s=1.0, float e=1.0f,
                                            float i=1.0);
    

    virtual void         overrideOutput(bool enable, const char *fname=0);
    bool                 getOutputOverride(UT_String &st, float t,
                                        bool expand = true) const;

    virtual void         overrideDevice(bool enable, bool interactive=false,
                                        const char *devicestr=0);
    bool                 getDeviceOverride(UT_String &str, float t, 
                                           bool expand = true) const;

    static void          setRenderButtonCB(void (*cb)(ROP_Node *, int fast));

    virtual void         inputConnectChanged(int which);
    
    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);

    virtual bool         getGeometryHandle(const char *path, float t,
                                           GU_DetailHandle &gdh,
                                           UT_DMatrix4 &world_xform)
                             { return(false); }

    // forces a BG render in executeSingle().
    void                 forceBackgroundRender(bool f = true)
                             { myForceBackgroundRender = f; }
    bool                 getForceBackgroundRender() const
                             { return myForceBackgroundRender; }

    /// Render this node using the parameters set in render_parms.
    bool                 renderCommand(ROP_RenderCmdParms &render_parms);

    // Copy the errors from this node into an error manager.  This method
    // is used to save off errors before they're cleared.
    void                 copyErrorsInto(UT_ErrorManager &error_manager)
                        { error_manager.stealErrors(*getLockedErrorManager()); }

    // Append the errors from an error manager into this node.
    void                 copyErrorsFrom(UT_ErrorManager &error_manager)
                        { getLockedErrorManager()->stealErrors(error_manager); }

    static void         setColorCorrectionIPGamma(bool enable, fpreal gamma);
    static fpreal       getColorCorrectionIPGamma();
    static void         setColorCorrectionIPLUT(bool enable, const char *lut);
    static const char  *getColorCorrectionIPLUT();

    static void         setColorCorrectionEnvVariables(bool set);
    static void         setFPSVariable(bool do_set = 0, float frame_inc = 1);


        
protected:
             ROP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
    virtual ~ROP_Node();

    // These OPs don't actually cook.  No data, nothing.  The renderFile()
    //  method is the closest thing to a cook.
    virtual OP_ERROR     cookMe(OP_Context &context);
    virtual OP_ERROR     bypassMe(OP_Context &context, int &copied_input);
    OP_ERROR             initFrameRange(float now, ROP_ExecuteContext &ctx);

    void                 addSystemError(const char *msg = 0)
                         { getLockedErrorManager()->systemError(msg);}
    void                 addError(int code, const char *msg = 0)
                         { getLockedErrorManager()->addError(ROP_OPTYPE_NAME, code, msg);}
    void                 addWarning(int code, const char *msg = 0)
                         { getLockedErrorManager()->addWarning(ROP_OPTYPE_NAME, code, msg); }
    void                 addMessage(int code, const char *msg = 0)
                         { getLockedErrorManager()->addMessage(ROP_OPTYPE_NAME, code, msg); }

    virtual float               getVariableValue(int index, int thread);

    // The endRender() method will always be called if startRender succeeds.
    virtual int                 startRender(int nframes,
                                            float tstart, float tend);
    virtual ROP_RENDER_CODE     renderFrame(float time,
                                            UT_Interrupt *boss = 0);
    virtual ROP_RENDER_CODE     endRender();


    TAKE_Take                   *applyRenderTake(const char *take);
    void                         restorePreviousTake(TAKE_Take *take);


    // Internal helper method that simply traverses our inputs and calls
    // buildRenderDependencies on them.
    virtual void          buildInputRenderDependencies(
                                               const ROP_RenderDepParms &parms);
   
    // This method returns the image device required to render it to an
    // interactive window (an mplay window, for example).
    virtual const char  *getInteractiveImageDevice() const { return ""; }
    
    virtual void        FSTART_SET(float val)
                { FLT_SET("f", 1, 0, 0, val); }
    virtual void        FEND_SET(float val)
                { FLT_SET("f", 1, 1, 0, val); }
    virtual void        FINC_SET(float val)
                { FLT_SET("f", 1, 2, 0, val); }
    virtual void        DORANGE_SET(int val)
                { INT_SET("trange", 0, 0, 0, val); }

    virtual void        RENDER_TAKE(UT_String &take)
                { evalString(take, "take", 0, 0.0f); }

    UT_String                    myRenderOutput;
    UT_String                    myRenderDevice;
    UT_String                    myRenderSuffix;
    float                        myRenderAspect;
    int                          myRenderX;
    int                          myRenderY;
    ROP_RenderMode               myRenderMode;
    int                          myCurrentFrame;
    int                          myTotalFrames;
    bool                         myExecuteSingle;

    ostream     *getVerbose() const { return myVerbose; }

protected:
    //
    //  These virtuals are methods that nobody should override...
    //  Except IPR buffers which are now saved as cooked data
    //
    //  I/O methods
    //
    virtual void         deleteCookedData();
    virtual int          saveCookedData(const char *, OP_Context &);
    virtual int          saveCookedData(ostream &os, OP_Context &,
                                        int binary = 0);

    // If there is a problem executing the script, then an error will be set
    // here.
    // Note that this has to remain protected (and not be made private) because
    // there are customers who inherit from ROP_Node and use this function.
    OP_ERROR     executeScript(
        UT_String &str, CH_ScriptLanguage language, float time);

private:
    virtual const char  *getFileExtension(int binary) const;

    static void  resetSimulation(OP_Node* node);

    ostream             *myVerbose;
    ROP_ExecuteContext  *myEContext;
    ROP_ExecuteOverride  myExecuteOverride;
    void                *myExecuteOverrideData;
    ROP_ExecuteOverride  myPreExecuteOverride;
    void                *myPreExecuteOverrideData;
    ROP_ExecuteOverride  myPostExecuteOverride;
    void                *myPostExecuteOverrideData;

    bool                 myForceBackgroundRender;
    
    bool                 myOverrideFrameRangeFlag;
    float                myOverrideStartFrame;
    float                myOverrideEndFrame;
    float                myOverrideFrameInc;

    bool                 myOverrideOutputFlag;
    UT_String            myOverrideOutputName;

    bool                 myOverrideDeviceFlag;
    UT_String            myOverrideDeviceName;

    bool                 myExecuteFull;         // Recursion check

    bool                 executeParmScript(const char *parm_name,
                                           float ttime);

    static int           doRenderCommand(CMD_Args &args, OP_Node *net,
                                         bool showerrors);

    static void          installCommands();
    static void          cmdRender(CMD_Args &args);
    static void          cmdRenderDeps(CMD_Args &args);
};

// These are the parms to the buildRenderDependencies methods.
class ROP_RenderDepParms
{
public:
                     ROP_RenderDepParms() :
                         myOrder(NULL),
                         myStart(0.0f),
                         myEnd(0.0f),
                         myFrameInc(0.0f),
                         myDoInputs(false),
                         myIgnoreBypass(true),
                         myIgnoreLocks(false),
                         myRenderSerial(-1),
                         myDepParent(NULL),
                         myTopLevelRop(NULL),
                         myFirstFrameFlag(true) { }

    // Set/Get RenderList
    void             setOrder(ROP_RenderList &order) { myOrder = &order; }
    ROP_RenderList  &getOrder() const { UT_ASSERT(myOrder); return *myOrder; }


    // Set/Get Frame Range
    void             setFrameRange(float start, float end, float finc)
                     { myStart = start; myEnd = end; myFrameInc = finc; }
    float            getStart()     const { return myStart; }
    float            getEnd()       const { return myEnd; }
    float            getFrameInc()  const { return myFrameInc; }

    // Set/Get Input traversal flags
    void             setDoInputsFlag(bool do_inputs) { myDoInputs = do_inputs; }
    bool             getDoInputs()         const { return myDoInputs; }

    // Set/Get TopLevel ROP -- this is the top most ROP that is traversed.  This
    // is used to prevent subnet traversals to go outside this ROP.  Only
    // useful when DoInputs is off.
    void             setTopLevelRop(ROP_Node *rop) { myTopLevelRop = rop; }
    ROP_Node        *getTopLevelRop() const        { return myTopLevelRop; }

    // Set/Get Ignore flags
    void             setIgnoreFlags(bool ignore_bypass, bool ignore_locks)
                     {
                         myIgnoreBypass = ignore_bypass;
                         myIgnoreLocks  = ignore_locks;
                     }
    bool             getIgnoreBypass() const { return myIgnoreBypass; }
    bool             getIgnoreLocks()  const { return myIgnoreLocks; }

    // Set/Get Render Serial number
    void             setRenderSerial(int render_serial) 
                     { myRenderSerial = render_serial; }
    int              getRenderSerial() const { return myRenderSerial; }

    // Set/Get Dependency parent
    void             setDepParent(ROP_RenderItem *dep_parent)
                     { myDepParent = dep_parent; }
    ROP_RenderItem  *getDepParent() const { return myDepParent; }

    void             setFirstFrame(bool first) { myFirstFrameFlag = first; }
    bool             isFirstFrame() const { return myFirstFrameFlag; }

private:
    ROP_RenderList      *myOrder;
    ROP_RenderItem      *myDepParent;
    ROP_Node            *myTopLevelRop;
    float                myStart;
    float                myEnd;
    float                myFrameInc;
    int                  myRenderSerial;
    bool                 myDoInputs;
    bool                 myDoIndirectInputs;
    bool                 myIgnoreBypass;
    bool                 myIgnoreLocks;
    bool                 myFirstFrameFlag;
};

#undef FLT_PARM
#undef INT_PARM
#undef STR_PARM
#undef FLT_SET
#undef INT_SET

#endif

---