ROP/ROP_IFDBase.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:        ROP_IFD_Base.h ( ROP Library, C++)
 *
 * COMMENTS:    Base class for IFD interface.  This class simply provides the
 *              interfaces required by ROP_IFDRender.  They are all defined as
 *              pure virtuals and must be defined by sub-classes.
 */

#ifndef __ROP_IFD_Base__
#define __ROP_IFD_Base__

#include "ROP_API.h"
#include <UT/UT_SysClone.h>
#include "ROP_Node.h"
#include "ROP_IPRList.h"
#include "ROP_IFDEvent.h"

class UT_Interrupt;
class IFD_Output;
class IFD_Scene;
class IFD_PassThru;
class IFD_ObjectParms;
class IFD_RenderDefinition;
class OBJ_Camera;
class OP_Bundle;
class IFD_IPRTree;
class IFD_StreamEvent;

class ROP_API ROP_IFDBase : public ROP_Node {
public:
             ROP_IFDBase(OP_Network *net, const char *name, OP_Operator *op);
    virtual ~ROP_IFDBase();

    static IFD_Scene            *getIFDScene();
    static PRM_Template          myObsoleteList[];

    virtual ROP_IFDBase         *castToROPIFDBase()     { return this; }

    // Get tag information for a specific renderer.
    // By default, this will attempt to evaluate a parameter with the token
    // name specified.  Therefore, you may not need to override this method.
    virtual int         getRenderTag(const char *token, UT_String &result,
                                     float now);

    void                setObjectParms(IFD_ObjectParms &parms, float now);

    virtual void        getIFDResolution(int &xres, int &yres, float &aspect,
                                            float now);

    virtual unsigned     disableParms();
    virtual int                  startRender(int nframes, float s, float e);
    virtual ROP_RENDER_CODE      renderFrame(float time, UT_Interrupt *);
    virtual ROP_RENDER_CODE      endRender();

    virtual IFD_RenderDefinition        *getRenderDefinition();
    virtual const char                  *getRenderName() = 0;

    /// IPR Handling
    ///    the IPR mode defaults to ROP_IPR_NONE
    virtual IFD_IPRTree *setupIPR(fpreal now);

    // Pure virtuals
    virtual const UT_String     &getRemoteHost() const = 0;
    virtual void        CAMERA(UT_String &name, float now) = 0;
    virtual void        VISIBLE(UT_String &pattern, float now) = 0;
    virtual const char  *VISIBLE_TOKEN() const = 0;
    virtual void        VISIBLEFOG(UT_String &pattern, float now) = 0;
    virtual const char  *VISIBLEFOG_TOKEN() const = 0;
    virtual void        ALIGHTS(UT_String &pattern, float now) = 0;
    virtual const char  *ALIGHTS_TOKEN() const = 0;
    virtual void        PICTURE(UT_String &name, float now) = 0;
    virtual void        getFrameDevice(UT_String &dev, float now,
                                        const char *renderer) = 0;
    virtual int         DOF() = 0;
    virtual float       DITHER(float now) = 0;
    virtual int         DORES() = 0;
    virtual int         RESX() = 0;
    virtual int         RESY() = 0;
    virtual int         DOSCRIPT() = 0;
    virtual int         BINARY() = 0;
    virtual int         BACKGROUND() = 0;
    virtual float       ASPECT() = 0;
    virtual float       GAMMA(float now) = 0;
    virtual int         SAMPLEX(float now) = 0;
    virtual int         SAMPLEY(float now) = 0;
    virtual float       JITTER(float now) = 0;
    virtual void        FIELD(UT_String &fields) = 0;
    virtual void        COMMAND(UT_String &cmd, float now) = 0;
    virtual void        SCRIPT(UT_String &file, float now) = 0;
    virtual void        BLUR(UT_String &blur) = 0;
    virtual int         INITSIM() = 0;
    virtual int         DISPSOP() = 0;

    virtual void        PRERENDER(UT_String &script, float now) = 0;
    virtual void        PREFRAME(UT_String &script, float now) = 0;
    virtual void        POSTFRAME(UT_String &script, float now) = 0;
    virtual void        POSTRENDER(UT_String &script, float now) = 0;
    
    virtual int         DOBUNDLEGROUPS() { return 0; }

    OP_Bundle *          getMaskBundle(float now, const char *tag,
                                       const char *filter);

    virtual OP_Bundle   *getVisibleBundle(float now);
    virtual OP_Bundle   *getVisibleIPRBundle(float now);
    virtual OP_Bundle   *getVisibleFogBundle(float now);
    virtual OP_Bundle   *getActiveLightBundle(float now);

    // Allow others to query IPR information
    // Possible queries are:
    //  parmenable      - The name of the parameter to enable/disable IPR
    //                    If no IPR rendering is supported, this fails
    //  isprerender     - Returns 1 if in pre-render mode
    virtual bool         getIPRParm(const char *token, UT_String &value);

    virtual bool         getIPRTag(const char *token, int idx,
                                    UT_String &value, fpreal now);
    IFD_IPRTree         *findIPR(fpreal now)
                            { return myIPRList.findTree(now); }

    virtual OBJ_Camera  *getCamera(float now);

    virtual void         getOutputResolution(int &x, int &y);
    
    static void          buildMotionBlurMenu(void *o, PRM_Name *, int,
                                             const PRM_SpareData *, PRM_Parm *);
    static int           clearIPRCache(void *data, int index, float time,
                                        const PRM_Template *tplate);


    UT_NotifierImpl<ROP_IFDEvent &>
                        &getEventNotifier()     { return myEventNotifier; }

protected:
    virtual void        handleStreamEvent(IFD_StreamEvent &event);

    // These three methods are called from startRender, renderFrame and
    // endRender to allow the caller to do different things.
    virtual int          startMultiFrame(IFD_Output *renderer,
                                    fpreal start, fpreal end, int nframes) = 0;
    virtual int          callRenderer(IFD_Output *renderer,
                                      float now) = 0;
    virtual int          endMultiFrame(IFD_Output *renderer) = 0;

    virtual bool         supportsExplicitMotionBlur() const { return false; }

    virtual IFD_Output  *createOutput(IFD_RenderDefinition &def);

    bool                setRIBVersionParms(IFD_Output *output,
                                          const char *version);

    UT_NotifierImpl<ROP_IFDEvent &>     myEventNotifier;

    IFD_Output                  *myOutput;
    IFD_Scene                   *myScene;
    IFD_Scene                   *myIFDScene;
    UT_PtrArray<IFD_PassThru *>  myPassThruList;
    int                          myStashCwd;
    float                        myEndTime;
    int                          mySaveExtraType;
    void                        *mySaveExtraData;
    ROP_IPRList                  myIPRList;
    UT_NotifierList              myNotifierList;

private:
    bool                 createScene(fpreal tstart);
    int                  doSingleFrame(IFD_Output *ren, fpreal now,
                                        UT_Interrupt *boss);
    static IFD_Scene    *theIFDScene;
};

#endif

---