IFD/IFD_PassThru.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:        DM library (C++)
 *
 * COMMENTS:    A simple "pass thru" interface.  This scene is constructed
 *              with another scene as a pseudo base class.  You can override
 *              the methods you want to without affecting the underlying
 *              pseudo-base class.  This allows you for example, to override
 *              the camera definitions, but still use a complicated object
 *              traversal mechanism (defined by another scene).
 *
 */

#ifndef __IFD_PassThru_h__
#define __IFD_PassThru_h__

#include "IFD_API.h"
#include "IFD_Scene.h"

class IFD_API IFD_PassThru : public IFD_Scene {
public:
             IFD_PassThru();
    virtual ~IFD_PassThru();

    virtual void         initialize(float now);
    virtual bool         finishFrame(int success, fpreal now);
    virtual void         setShutterTime(float shutter, int nsegs);

    virtual void         replaceBaseScene(IFD_Scene *scene);

    IFD_Scene           *getBase()      { return myBase; }

//
//  Get the name of the output image
    virtual void         getOutputImage(UT_String &str, float t,
                                                const char *rtype);
    virtual void         getOutputDevice(UT_String &str, float t,
                                                const char *rtype);

    virtual int          getRenderTag(const char *token, UT_String &value,
                                      float now);
    virtual bool         getLightTag(const char *token, int i,
                                    UT_String &value, float now);
    virtual bool         getObjectTag(const char *token, int i,
                                    UT_String &value, float now);
    virtual bool         getGeometryTag(const char *token, int i,
                                    UT_String &value, float now);
    virtual bool         getAtmosphereTag(const char *token, int i,
                                    UT_String &value, float now);
    virtual bool         getSpaceTag(const char *token, int i,
                                    UT_String &value, float now);
    virtual bool         getIPRTag(const char *token, int index,
                                    UT_String &value, float now);
//
//  Query methods to get the number of lights & number of objects in the scene
    virtual int          getNLights(float now);
    virtual int          getNObjects(float now);
    virtual int          getNSpaces(float now);
    virtual int          getNGeometry(float now);
    virtual int          getNAtmosphere(float now);
    virtual int          getNIPR(fpreal now);

    virtual int          doDepthOfField(float now);
    virtual float        getDither(float now);

//  By default, doMotionBlur will traverse all objects and lights and determine
//      if there is any motion blur in the whole scene (cameras too)
    virtual int           doMotionBlur(float now);
    virtual IFD_BLUR_TYPE doCameraBlur(float now);      // Camera blur?
    virtual IFD_BLUR_TYPE doObjectBlur(int idx, float now);     // Object blur?
    virtual IFD_BLUR_TYPE doGeometryBlur(int idx, float now);   // Geo blur?
    virtual IFD_BLUR_TYPE doLightBlur(int idx, float now);      // Light blur?

    virtual void         getCameraPreInclude(UT_WorkBuffer &str, float now,
                                        const char *rtype);
    virtual void         getCameraPostInclude(UT_WorkBuffer &str, float now,
                                        const char *rtype);
    virtual void         getObjectPreInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getObjectPostInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getLightPreInclude(int idx, UT_WorkBuffer &str, 
                                        float now, const char *rtype);
    virtual void         getLightPostInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getAtmospherePreInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getAtmospherePostInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getSpacePreInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getSpacePostInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getIPRPreInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getIPRPostInclude(int idx, UT_WorkBuffer &str,
                                        float now, const char *rtype);
    virtual void         getRenderGenericInclude(const char *parm_name,
                                        UT_WorkBuffer &str, float now);

//
//  Query methods to get camera information from the scene
    virtual void         getCameraParms(IFD_CameraParms &parms, float now,
                                            const char *);
    virtual void         getCameraTransform(UT_DMatrix4 &xform, float now);

    virtual void         getLensShader(UT_String &shader, float now,
                                        const char *rtype);
    virtual void         getImagerShader(UT_String &shader, float now,
                                        const char *rtype);

    virtual int                  getBackgroundImage(UT_String &filename,
                                                    float now);
    virtual const IMG_Raster    *getBackgroundImage(float now,
                                                    int xres=0, int yres=0);

// The following method uses the texture cache, so may limit the resolution
// of the returned raster.
    virtual const TIL_Raster    *getBackgroundImageRaster(float now,
                                                    int xres=0, int yres=0);

// General method for testing mask membership
// 
    virtual bool         isObjectMaskMember(float now, int obj_idx,
                                            const char *tag);

//
//  Query methods to get light info.  The index of the light in question is
//      passed to the query methods
//      getLightShader()        - gets the shader for the light
//      getShadowName()         - gets name of auto-gen shadow file,
//                                      returns 0 for no generation of file
    virtual void         getLightName(int idx, UT_String &str);
    virtual int          getLightIndex(const char *name);
    virtual void         getLightShader(int idx, UT_String &str, float now,
                                        const char *rtype);
    virtual void         getShadowShader(int idx, UT_String &str, float now,
                                        const char *rtype);
    virtual void         getEmitterShader(int idx, UT_String &str, float now,
                                        const char *rtype);
    virtual int          getAutogenFlag(int idx, float now);
    virtual void         getShadowName(int idx, UT_String &str, float now);
    virtual void         getLightParms(int idx, IFD_CameraParms &parms,
                                        float now, const char *rtype);
    virtual void         getLightParms(int idx, IFD_LightParms &parms,
                                        float now, const char *rtype);
    virtual void         getLightTransform(int idx, UT_DMatrix4 &mat,
                                        float now);
    virtual void         getShadowMask(int idx, UT_String &str, float t);

//  Query methods to get info about atmosphere shaders.  The index of the
//      atmosphere object is passed to the query methods
//      getAtmosphereShader()   - gets the shader for the atmosphere
//      getAtmosphereTransform()- gets the transform for the atmosphere
    virtual void         getAtmosphereName(int idx, UT_String &str);
    virtual int          getAtmosphereIndex(const char *name);
    virtual void         getAtmosphereShader(int idx, UT_String &str,
                                        float now, const char *rtype);
    virtual int          getAtmosphereGeometry(int idx);
    virtual void         getAtmosphereTransform(int idx, UT_DMatrix4 &mat,
                                        float now);
    virtual void         getAtmosphereParms(int idx, IFD_ObjectParms &parms,
                                        float now, const char *rtype);

//
//  Query methods for geometry info.  The index of the object in question is
//      passed to the query methods.
//      getObjectShader()       - gets the object shader string
//      getInteriorShader()     - gets interior shader
//      isObjectLit()           - determines light mask information
    virtual void         getObjectName(int idx, UT_String &str, int unique);
    virtual int          getObjectIndex(const char *name);

    virtual void         getObjectShader(int idx, UT_String &str, float now,
                                const char *rtype);
#if 0
    virtual const void  *getObjectShader(int idx, float now,const char *rtype);
#endif
    virtual void         getObjectShaderTransform(int idx, UT_DMatrix4 &xform,
                                float now);
    virtual void         getInteriorShader(int i, UT_String &str, float now,
                                const char *rtype);
    virtual void         getInteriorShaderTransform(int idx, UT_DMatrix4 &xform,
                                float now);
    virtual void         getDisplacementTransform(int idx, UT_DMatrix4 &xform,
                                float now);
    virtual void         getDisplacementShader(int idx, UT_String &str,
                                float t, const char *rtype);
    virtual void         getGeometryShader(int idx, UT_String &str, float t,
                                const char *rtype);
    virtual void         getSurfaceEnvironmentShader(int idx, UT_String &str,
                                float t, const char *rtype);
    virtual void         getSurfaceShadowShader(int idx, UT_String &str,
                                float t, const char *rtype);
    virtual void         getPhotonShader(int idx, UT_String &str, float t,
                                const char *rtype);
    virtual void         getPhotonVolumeShader(int idx, UT_String &str,
                                float t, const char *rtype);
    virtual void         getContourShader(int idx, UT_String &str, float t,
                                const char *rtype);
    virtual int          isObjectLit(int objIndex, int lightIndex, float now);
    virtual int          isObjectShadower(int objIndex, int lightIndex,
                                        float now);
    virtual int          isAutoReflect(int objIndex, float t, UT_String &map);
    virtual int          getAutoReflectResolution(int obj, float now);
    virtual int          isObjectReflected(int objIndex, int reflObjIndex,
                                        float now);
    virtual void         getReflectMask(int objIndex, UT_String &str, float t);
    virtual void         getObjectParms(int idx, IFD_ObjectParms &parms,
                                        float now, const char *rtype);
    virtual void         getObjectTransform(int idx, UT_DMatrix4 &xform,
                                        float now);
    virtual int          getObjectGeometry(int idx);
    virtual IFD_PHOTON_MODE     getObjectCausticsMode(int idx, float t);
    virtual IFD_PHOTON_MODE     getObjectGlobalIllumMode(int idx, float t);

    virtual void         getSpaceName(int idx, UT_String &name);
    virtual void         getSpaceTransform(int idx, UT_DMatrix4 &xform,
                                        float now);
    virtual void         getIPRName(int idx, UT_String &name);

    virtual void         getGeometryName(int idx, UT_String &name);
    virtual GU_Detail   *getGeometry(int idx, float now);
    virtual void         releaseGeometry(int idx);
    virtual void         getGeometryParms(int idx, IFD_GeometryParms &parms,
                                        float now, const char *rtype);
    virtual void         getObjectParms(int idx, IFD_GeometryParms &parms,
                                        float now, const char *rtype);
    virtual void         getInstanceGroups(int idx, UT_String &groups);

    virtual IFD_IPRTree *getIPRTree(int idx);

    virtual int          getNumObjectBundles(int obj_idx);
    virtual const char  *getObjectBundleName(int obj_idx, int bundle_idx);
    virtual bool         outputBundleNames();



//
//  Here are the methods required for reading an IFD
//
    virtual void         addWorld(const char *name,
                                  const char *atmosphereShader);

    virtual void         addCamera(const char *name,
                                   IFD_CameraParms &cparms,
                                   const UT_DMatrix4 &xform,
                                   const char *parent);

    virtual void         addLight(const char *name,
                                  IFD_LightParms &parms,
                                  IFD_CameraParms &cparms,
                                  const UT_DMatrix4 &xform,
                                  const char *parent);

//
//  Note, the gdp is stolen by the scene!
    virtual void         addObject(const char *name, GU_Detail *gdp,
                                IFD_GeometryParms &parms, 
                                const UT_DMatrix4 &xform,
                                const char *parent,
                                const char *material,
                                const char *shader,
                                const char *displacement,
                                const char *interior);

protected:
    IFD_Scene           *myBase;
private:
};

#endif

---