IFD/IFD_Output.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:        IFD base class (C++)
 *
 * COMMENTS:    This class handles output to different renderers
 *
 */

#ifndef __IFD_Output_h__
#define __IFD_Output_h__

#include "IFD_API.h"
#include <sys/types.h>
#include <iostream.h>
#include <UT/UT_ErrorManager.h>
#include <UT/UT_Signal.h>
#include <UT/UT_SysClone.h>
#include "IFD_Include.h"
#include "IFD_StreamEvent.h"
#include "IFD_Error.h"

class GU_Detail;
class IFD_Scene;
class IFD_CameraParms;
class IFD_ObjectParms;
class IFD_RenderDefinition;
class IFD_RenderStream;

class IFD_API IFD_Output {
public:
                 IFD_Output();
    virtual     ~IFD_Output();

//  Determine what our name is
    virtual const char  *renderer() const = 0;

    virtual int          openMultiFrame(IFD_Scene &scene,
                                        fpreal start, fpreal end, int nframes);
    virtual int          doSingleFrame(IFD_Scene &scene, float time);
    virtual int          doField(IFD_Scene &, float time,
                                        const char *fields, float time_inc=0);
    virtual int          createArchive(IFD_Scene &scene, float time);
    virtual int          closeMultiFrame(IFD_Scene &scene);

    // This is a hook which allows the IFD_Output to set specific parameters up
    // AFTER the parms have been initialized by the houdini object.
    virtual void         setObjectParms(IFD_ObjectParms &parms, float now,
                                        IFD_Scene &scene);

    void                 setTargetName(const char *name);
    void                 setTargetVersion(int major, int minor)
                         {
                             myTargetVersion = major*1000 + minor;
                         }
    void                 getTargetVersion(int &major, int &minor) const
                         {
                             major = myTargetVersion / 1000;
                             minor = myTargetVersion % 1000;
                         }
    const char          *getTargetName(const char *def=0)
                         { return myTargetName.isstring()
                                  ? (const char *)myTargetName : def ;
                         }
    int                  isVersion(int major, int minor) const
                         {
                             return myTargetVersion >= major*1000 + minor;
                         }

    IFD_RenderStream    *getStream()    { return myStream; }

    void                 addSystemError(const char *msg = 0)
                            { UTaddSystemError(msg); }
    void                 addError(int code, const char *msg = 0)
                            { UTaddError("IFD", code, msg); }
    void                 addWarning(int code, const char *msg = 0)
                            { UTaddWarning("IFD", code, msg); }

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

protected:
    // Move a detail for motion blur purposes.  The user should specify the
    // shutter time (in seconds).  Specifying a positive time will move into
    // the future, a negative time will move back...
    // Returns 1 if it moved the geometry
    int                  moveDetail(GU_Detail *gdp, float direction);

    fpreal               computeTimeStep(fpreal start, fpreal end, int nframes)
                         {
                             return (end - start) / (fpreal)nframes;
                         }

    ostream             *openStream(IFD_Scene &scene, float time);
    void                 closeStream();

    void                 getTimeRange(float &tstart, float &tend, float &fps);
    float                getFPS() const { return myFPS; }
    int                  isLightUsed(IFD_Scene &scene, int lidx, float now);

    void                 writeIncludeBuffer(ostream &os, 
                                            const UT_WorkBuffer &buf);

    int                  myTargetVersion;
    UT_String            myTargetName;

    // This function will get information from the scene and camera and
    //  figure out the shutter time as well as what type of motion blur
    //  should be done on the scene in general.
    int                 getMotionBlur(IFD_Scene &scene, float &shutter,
                              const IFD_CameraParms &parms, float now,
                              int num_motion_segments=2) const;
protected:
    UT_NotifierImpl<IFD_StreamEvent &>  myEventNotifier;
    IFD_RenderStream                    *myStream;
    float                                myFPS;
};

#endif

---