ROP/ROP_IFD.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        ROP library (C++)
 *
 * COMMENTS:    Base class for IFD type renderers
 *
 */

#ifndef __ROP_IFD_h__
#define __ROP_IFD_h__

#include "ROP_API.h"
#include "ROP_IFDBase.h"

class IFD_Output;
class IFD_Scene;
class IFD_PassThru;
class OBJ_Camera;
class TIL_Sequence;

//___________________________________________________________________________

#define FLOAT_PARM(name, idx, vi, t)    \
            { return evalFloat(name, vi, t); }
#define INT_PARM(name, idx, vi, t) \
            { return evalInt(name, vi, t); }
#define STR_PARM(name, idx, vi, t) \
            { evalString(str, name, vi, (float)t); }

#define INT_SET(name, idx, vi, t, val)  \
            { setInt(name, vi, t, val); }
#define STR_SET(name, idx, vi, t) \
            { setString(str, meaning, name, vi, (float)t); }
#define STR_GET(name, idx, vi, t) \
            { evalStringRaw(str, name, vi, (float)t); }
//___________________________________________________________________________

enum {
    ROP_IFD_RENDER,
    ROP_IFD_RENDER_CTRL,
    ROP_IFD_TRANGE,
    ROP_IFD_FRANGE,
    ROP_IFD_TAKE,

    ROP_IFD_SWITCHER,

    // Page 1: Main
    ROP_IFD_RENDERER,
    ROP_IFD_PICTURE,
    ROP_IFD_CAMERA,
    ROP_IFD_BUNDLEMODE,
    ROP_IFD_VOBJECT,
    ROP_IFD_VFOG,
    ROP_IFD_ALIGHT,
    ROP_IFD_USEDISPLAY,
    ROP_IFD_INITSIM,
    ROP_IFD_TSCRIPT,
    ROP_IFD_SCRIPT,
    ROP_IFD_BINARY,
    ROP_IFD_BACKGROUND,
    ROP_IFD_COMMAND,
    ROP_IFD_TRES,
    ROP_IFD_RES,
    ROP_IFD_RESNAME,
    ROP_IFD_ASPECT,
    ROP_IFD_FIELD,
    ROP_IFD_SAMPLE,
    ROP_IFD_MBLUR,
    ROP_IFD_BLUR,
    ROP_IFD_DOF,
    ROP_IFD_JITTER,
    ROP_IFD_DITHER,
    ROP_IFD_GAMMA,

    // Page 2: Scripts
    ROP_IFD_TPRERENDER,
    ROP_IFD_PRERENDER,
    ROP_IFD_LPRERENDER,
    ROP_IFD_TPREFRAME,
    ROP_IFD_PREFRAME,
    ROP_IFD_LPREFRAME,
    ROP_IFD_TPOSTFRAME,
    ROP_IFD_POSTFRAME,
    ROP_IFD_LPOSTFRAME,
    ROP_IFD_TPOSTRENDER,
    ROP_IFD_POSTRENDER,
    ROP_IFD_LPOSTRENDER,

    // Invisible parameters

    ROP_IFD_MAXPARMS
};


class ROP_API ROP_IFD : public ROP_IFDBase
{
public:
    virtual unsigned     disableParms();
    virtual ROP_IFD     *castToROPIFD()   { return this; }
    virtual bool         hasImageOutput() { return 1; }
    virtual int          isMantra3() const;
    virtual const char  *getRenderName();

    static CH_LocalVariable      myVariableList[];
    static PRM_Template         *getTemplates();
    static OP_Node              *myConstructor(OP_Network *net, const char*name,
                                                OP_Operator *op);

    static int                   pictureChanged(void *o, int idx, float t,
                                    const PRM_Template *tplate);

    // Add a pass through scene.  Pass thru scenes modify the 
    // operation of the IFD_Scene for the duration of a render.
    // When the render is completed, the objects are removed.
    void                addPassThru(IFD_PassThru *scn) 
                        { myPassThruList.append(scn); }

    // If the remote variables are set, then we will use the built-in IFD
    // network management.  Otherwise, we'll just use the remote host as a
    // label.
    void                 setRemoteHost(const char *hostname)
                         {
                             myRemoteHost.harden(hostname);
                         }
    virtual const UT_String     &getRemoteHost() const { return myRemoteHost; }

    virtual void         getRenderedImageInfo(TIL_Sequence &seq);

    virtual void         getOutputFile(UT_String &filename)
                         { evalStringRaw(filename, "picture", 0, 0.0f); }
protected:
             ROP_IFD(OP_Network *net, const char *name, OP_Operator *entry);
    virtual ~ROP_IFD();

    // This method provides a callback to the output driver whenever the
    // picture parameter is changed.  By default, nothing is done.
    virtual int          changePicture(int, float, const PRM_Template *);

    // Some ROP's require the renderer menu - but a limited sub-set (i.e. OGL)
    virtual void         buildRendererMenu(PRM_Name *, int,
                                    const PRM_SpareData *, PRM_Parm *);

    virtual int          startMultiFrame(IFD_Output *renderer,
                                         fpreal start, fpreal end, int nframes);
    virtual int          callRenderer(IFD_Output *renderer, float now);
    virtual int          endMultiFrame(IFD_Output *renderer);

public:

    void  RENDERER(UT_String &str)              { STR_PARM("renderer",0, 0,0) }
    virtual void  CAMERA(UT_String &str, float t)
                        { STR_PARM("camera",  1, 0, t) }
    virtual void  VISIBLE(UT_String &str, float t)
                        { STR_PARM("visible", 2, 0, t) }
    virtual const char  *VISIBLE_TOKEN() const  { return "visible"; }
    virtual void  VISIBLEFOG(UT_String &str, float t)
                        { STR_PARM("visiblefog", 32, 0, t) }
    virtual const char  *VISIBLEFOG_TOKEN() const       { return "visiblefog"; }
    virtual void  ALIGHTS(UT_String &str, float t)
                        { STR_PARM("activelights", 31, 0, t) }
    virtual const char  *ALIGHTS_TOKEN() const  { return "activelights"; }
    virtual int   DISPSOP()                     { INT_PARM("dispsop", 3, 0, 0) }
    virtual int   INITSIM()                     { INT_PARM("initsim", 4, 0, 0) }

    virtual int   DOSCRIPT()
                  {
                      UT_String d;
                      if(getRenderMode() == RENDER_PRM &&
                         !getOutputOverride(d,0.0f))
                          INT_PARM("tscript", 5, 0, 0)
                      else
                          return 0;
                  }
    
    virtual int   BINARY()                      { INT_PARM("binary",  7, 0, 0) }
    virtual void  SCRIPT(UT_String &str, float t)
                        { STR_PARM("script",  6, 0, t) }
    virtual void  COMMAND(UT_String &str, float t)
                        { STR_PARM("command", 8, 0, t);
                          getQualityModifier(str); }

    // by default, this does nothing...
    virtual void  getQualityModifier(UT_String & /*render_cmd*/) { }

    // GETCOMMAND - doesn't expand the string
    virtual void  GETCOMMAND(UT_String &str)
                        { STR_GET("command", 8, 0, 0);
                          getQualityModifier(str); }
    virtual void  SETCOMMAND(UT_String &str, CH_StringMeaning meaning, float t)
                        { STR_SET("command", 8, 0, t) }

    virtual void  PICTURE(UT_String &str, float t)
                                { if( getRenderMode() == RENDER_PRM )
                                  {
                                      if(!getOutputOverride(str, t))
                                      { STR_PARM("picture", 9, 0, t) }
                                  }
                                  else
                                      str = getRenderOutput();
                                }
    void  RAW_PICTURE(UT_String &str)
                                { if( getRenderMode() == RENDER_PRM )
                                  {
                                      if(!getOutputOverride(str, 0.0f, false))
                                      { STR_GET("picture", 9, 0, 0) }
                                  }
                                  else
                                      str = getRenderOutput();
                                }

    virtual int   DOF()                 { INT_PARM  ("dof",     10, 0, 0) }
    virtual float JITTER(float t)       { FLOAT_PARM("jitter",  11, 0, t) }
    virtual float DITHER(float t)       { FLOAT_PARM("dither",  12, 0, t) }
    virtual float GAMMA(float t)        { FLOAT_PARM("gamma",   13, 0, t) }
    virtual int   SAMPLEX(float t);
    virtual int   SAMPLEY(float t);
    virtual void  FIELD(UT_String &str) { STR_PARM  ("field",   15, 0, 0) }
    virtual void  BLUR(UT_String &str)  { STR_PARM  ("blur",    16, 0, 0) }
            void  SETBACKGROUND(int v)  { INT_SET("background", 17, 0, 0, v) }
    virtual int   BACKGROUND()
        { if(getDependencyRenderFlag())
            return 0;
        else if( getRenderMode() == RENDER_PRM)
            INT_PARM("background", 17, 0, 0)
        else
            return 1;
        }

    virtual int   DORES()       { if( getRenderMode() == RENDER_PRM )
                                    { INT_PARM  ("tres", 20, 0, 0) }
                                  else
                                    return 1;
                                }

    virtual int   RESX()        { if( getRenderMode() == RENDER_PRM )
                                    { INT_PARM  ("res", 21, 0, 0) }
                                  else
                                    return getRenderResX();
                                }

    virtual int   RESY()        { if( getRenderMode() == RENDER_PRM )
                                    { INT_PARM  ("res", 21, 1, 0) }
                                  else
                                    return getRenderResY();
                                }


    virtual float ASPECT()      { if( getRenderMode() == RENDER_PRM ||
                                      getRenderAspect() <= 0 )
                                    { FLOAT_PARM("aspect", 22, 0, 0) }
                                  else
                                    return getRenderAspect();
                                }

    virtual void         getFrameDevice(UT_String &str, float t,
                                        const char *rtype);

    static int  setResCback(void *o, int index, float t, const PRM_Template *);
    static void buildRenderMenu(void *rop, PRM_Name *, int, const PRM_SpareData *, PRM_Parm *);
    static void buildShopMenu(PRM_Name *, int max, int shop_type);

    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);
protected:
    virtual void        PRERENDER(UT_String &str, float t)
                            { STR_PARM("prerender", 25, 0, t); }
    virtual void        POSTRENDER(UT_String &str, float t)
                            { STR_PARM("postrender", 26, 0, t); }
    virtual void        PREFRAME(UT_String &str, float t)
                            { STR_PARM("preframe", 27, 0, t); }
    virtual void        POSTFRAME(UT_String &str, float t)
                            { STR_PARM("postframe", 28, 0, t); }

private:

    UT_String            myRemoteHost;
};

#undef FLOAT_PARM
#undef INT_PARM
#undef STR_PARM
#undef STR_GET
#undef STR_SET
#undef INT_SET

#endif

---