IFD/IFD_Scene.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 library (C++)
 *
 * COMMENTS:    This class provides call backs to a scene.  This allows the
 *              IFD to query the scene to get information it needs.
 *
 */

#ifndef __IFD_Scene_h__
#define __IFD_Scene_h__

#include "IFD_API.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_BoundingBox.h>
#include "IFD_Include.h"

class UT_WorkBuffer;
class GU_Detail;
class GB_AttributeRef;
class GEO_Detail;
class GEO_Point;
class IMG_Raster;
class TIL_Raster;
class IFD_IPRTree;

enum IFD_AUTOGEN_TYPE {
    IFD_AUTOGEN_NONE = 0,       // No depth map generation
    IFD_AUTOGEN_NEAR,           // Generate closest Z value for depth map
    IFD_AUTOGEN_MID,            // Generate mid-point value for depth map
    IFD_AUTOGEN_FAR,            // Generate farthest Z value for depth map
    IFD_AUTOGEN_AVERAGE         // Generate average Z value for depth map
};

enum IFD_AREALIGHT_TYPE {
    IFD_AREA_POINT,     // Point light
    IFD_AREA_LINE,      // Line light
    IFD_AREA_GRID,      // Grid shaped area
    IFD_AREA_DISK,      // Disk shaped light
    IFD_AREA_SPHERE,    // Sphere shaped light
    IFD_AREA_TUBE       // Tube shaped light
};

class IFD_API IFD_CameraParms {
public:
    IFD_CameraParms()   { setDefaults(); }
    void                setDefaults();
    float               focal;                  // Focal length
    float               aperture;               // Aperture
    float               aspect;                 // Aspect ratio
    float               focus;                  // Focus distance
    float               fstop;                  // F-Stop;
    float               curvature;              // Lens curvature
    int                 xres, yres;             // Resolution for camera
    float               cropx[2];               // Min max for cropping in x
    float               cropy[2];               // Min max for cropping in y
    float               winx[2];                // Sub-windowing in X
    float               winy[2];                // Sub-windowing in Y
    float               mynear, myfar;          // Near/Far clipping planes
    float               jitter;                 // Jitter scale
    float               shutterTime;            // Shutter time for the camera
    float               gamma, gain;            // Camera gamma & gain
    float               shaderRate;             // Global shading rate
    int                 samplex, sampley;       // Anti-alias sampling
    IFD_PROJECTION      projection;
    float               orthoZoom;              // Orthographic zoom
    int                 field;                  // 0 = none, 1 = even, 2 = odd
    UT_String           fieldPic;               // Background field picture
};

class IFD_API IFD_LightParms {
public:
    IFD_LightParms()    { setDefaults(); }
    void        setDefaults();
    float       r, g, b;                // Color of light
    float       spread;
    float       atten;
    float       angle, delta, roll;     // Cone parameters
    int         isAmbient;              // An ambient light source
    int         isDiffuseLight;         // Contributes to diffuse shading
    int         isSpecularLight;        // Contributes to specular shading
    int         isCone;
    int         isAtten;
    float       reflectX, reflectY;
    float       er, eg, eb;                     // Light energy
    float       exponent;                       // Exponent of energy falloff
    float       myActiveRadius;                 // Active radius for light
    int         causticStore, causticEmit;      // Caustics photons
    int         globillumStore, globillumEmit;  // Global illumination photons
    UT_String   reflectionMap;
    UT_String   diffuseMap;
    UT_String   slideMap;
    UT_String   zdepthMap;
    IFD_AREALIGHT_TYPE  myAreaShape;
    float               myAreaSamples;
    float               myAreaSize;

    int                 myDepthSamples[2];
    IFD_BLUR_TYPE       myDepthBlur;
    int                 myDepthDOF;

    // Photons spawned from this light source contribute to direct
    // illumination.  Otherwise, only secondary photons are stored in maps.
    int         myPhotonDirect;
};

class IFD_API IFD_GeometryParms {
public:
    IFD_GeometryParms() { setDefaults(); }
    void                setDefaults()
                        {
                            smoothShaded = 1;
                            backfaceRemove = 0;
                            validBox = 0;
                            shutterBlur = 0;
                            myAutoArchive = 0;
                            myInterpretation = IFD_GEO_AS_IS;
                            myFileName = 0;
                            myProceduralName = 0;
                        }

    IFD_GEO_INTERP      myInterpretation;
    unsigned int        smoothShaded:1,         // Smooth shade polys
                        backfaceRemove:1,       // Remove backfaces
                        validBox:1,             // Valid bounding box
                        shutterBlur:1,          // Blend files based on shutter
                        myAutoArchive:2;        // Auto-generate archive
    UT_String           myFileName;
    UT_String           myProceduralName;
    UT_BoundingBox      myFileBound;
};

class IFD_API IFD_ObjectParms {
public:
    IFD_ObjectParms()   { setDefaults(); }
    void        setDefaults();
    int         isRendered;             // Is object on for display?
    int         isMatte;                // Is object matte object
    int         isPhantom;              // Is object phantom object
    int         reflectbounce;          // Reflect bounces
    int         transmitbounce;         // Transmit bounce
    float       rayclip;                // Clipping threshold for rays
    float       displaceBounds;         // Displacement bounds
    float       shaderRate;             // Shading rate
    float       reflectShaderRate;      // Reflection shader rate
    float       shadowShaderRate;       // Shadow shader rate
    float       envShaderRate;          // Environment map shader rate
    float       transmitShaderRate;     // Transmission shader rate
    float       levelOfDetail;          // Level of detail
};

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

//
//  Here are all the methods required for outputting an IFD
//
    virtual void         initialize(float now);
    virtual bool         finishFrame(int success, fpreal now);

//
//  When computing transforms for deformation blur per-point instancing, the
//  scene needs to know about shutter time and motion segments.  The scene
//  cannot garner this information since it doesn't know about FPS and other
//  critical information which is available to the output driver.  This should
//  be called by the output driver before any transforms are evaluated.
//  The shutter time should be expressed in seconds.
//
    virtual void         setShutterTime(float shutter, int nsegments);

//
//  Get the name of the output image
/// Throughout IFD_Scene, many parameters can have different values for
/// different renderers (for example, in shaders). The parameter rtype is used
/// by Houdini to choose the "right" value for the target renderer.  For
/// example, with shaders, a SHOP_Clerk is found which can handle the
/// appropriate type (i.e. "RIB", "VMantra", "OGL", etc.)
    virtual void         getOutputImage(UT_String &str, float t,
                                                const char *rtype) = 0;
    virtual void         getOutputDevice(UT_String &str, float t,
                                                const char *rtype);

//
//  Some renderers may want to specify additional information about the "state"
//  for rendering (for example, setting a filter for rendering).  This can be
//  done through the tag mechanism.  The tag token should be unique for the
//  renderer in question (i.e. prefix the tag with something unique).
//  If the tag is not available, then 0 is returned and the value string is not
//  modified.  Otherwise, the value string is replaced with the "correct" value
//  for the tag.
    virtual int          getRenderTag(const char *token, UT_String &value,
                                        float now);
    virtual bool         getLightTag(const char *token, int index,
                                        UT_String &value, float now);
    virtual bool         getObjectTag(const char *token, int index,
                                        UT_String &value, float now);
    virtual bool         getGeometryTag(const char *token, int index,
                                        UT_String &value, float now);
    virtual bool         getAtmosphereTag(const char *token, int index,
                                        UT_String &value, float now);
    virtual bool         getSpaceTag(const char *token, int index,
                                        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          getNGeometry(float now);
    virtual int          getNAtmosphere(float now);
    virtual int          getNSpaces(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 *rtype);
    virtual void         getCameraTransform(UT_DMatrix4 &xform, float now);

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

//  These methods return the image for the background.  With the first, the
//  method will return 0 if there is no background image.  With the second it
//  will return a null ptr if no background exists.  You should not delete the
//  raster returned.  It is possible to specify a resolution to load the raster
//  at (it will be filter scaled to the specified res).
    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 &m, 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 *rtyp);

//
//  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
// When querying the name of an object, there is a "unique" flag.  This is used
// when there are multiple instances generated from one Houdini object (i.e.
// per-point instancing).  If there are multiple instances, and the unique flag
// is set, then the names returned will be pretty much guaranteed unique.
// However, to get the base name of the object (i.e. for pattern matching), the
// unique flag should be passed in as 0.
    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
//  this one is for getting data from object shaders that aren't in textural
//  string form.  Here it defaults to returning NULL. 
//  (vince 16/Aug/1999)
    virtual const void  *getObjectShader(int idx, float t, 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 now, 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 now, 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);
    // Returns whether the object is reflected in reflObjIndex
    virtual int          isObjectReflected(int objIndex, int reflObjIndex,
                                        float now);
    virtual void         getReflectMask(int objIndex, UT_String &str, float t);
    virtual int          isAutoReflect(int objIndex, float now,
                                        UT_String &mapname);
    virtual int          getAutoReflectResolution(int objIndex, float now);
    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         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         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         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);

    // Returns the number of bundles to which the object obj_idx belongs.
    virtual int          getNumObjectBundles(int obj_idx);

    // Returns the name of a bundle to which obj_idx belongs.
    virtual const char  *getObjectBundleName(int obj_idx, int bundle_idx);

    // Returns whether or not the IFD should use bundles to output the grouping
    // structure of the objects.
    virtual bool         outputBundleNames();



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

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

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

//
//  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 = 0,
                                const char *material = 0,
                                const char *shader = 0,
                                const char *displacement = 0,
                                const char *interior = 0) = 0;

    //
    // dereferenceShopShader() will test to see that shader_attrib doesn't
    // already exist.  If it doesn't, but the shopref attribute does exist, it
    // will de-reference the SHOPs and create the shader_attrib string.  The
    // function returns 1 if the shader_attrib is created (this allows users to
    // clean up properly after the fact).
    //
    static int           dereferenceShopShader(GEO_Detail *gdp,
                                const char *shopref,
                                const char *objpath,
                                const char *shader_attrib,
                                int shop_type,
                                const char *rtype, float now);

    //
    // This is a convenience method to resolve SHOPs for particular renderers.
    // The method returns 1 if the path is resolved properly (and the shader
    // string will be evaluated).
    //
    static int           resolveShopString(UT_String &shader,
                                        const char *shop_path,
                                        const char *objpath,
                                        int shop_type,
                                        const char *renderer_name,
                                        float now);

    // This method will find the local transform for a point for instancing
    // geometry on the point.
    // The tscale parameter will cause the point to be "moved" along the
    // velocity vector when making the transform.  The tscale parameter should
    // be in seconds.
    static void          getInstanceTransform(UT_DMatrix4 &xform,
                                  const GEO_Point *ppt,
                                  const GB_AttributeRef &v_off, // "v"
                                  const GB_AttributeRef &n_off, // "N"
                                  const GB_AttributeRef &pscale_off,    // "pscale"
                                  const GB_AttributeRef &pscale3_off,   // "scale[3]"
                                  const GB_AttributeRef &up_off,        // "up"[3]
                                  const GB_AttributeRef &rot_off,       // "rot"[4]
                                  const GB_AttributeRef &trans_off,     // "trans"[3]
                                  const GB_AttributeRef &orient_off,    // "orient"[4]
                                  float tscale);

    int                  myExtraDataType;
    void                *myExtraData;

protected:

    void                 setDefaultParms(IFD_CameraParms &parms)
                         { parms.setDefaults(); }
    void                 setDefaultParms(IFD_LightParms &parms)
                         { parms.setDefaults(); }
    void                 setDefaultParms(IFD_ObjectParms &parms)
                         { parms.setDefaults(); }
    void                 setDefaultParms(IFD_GeometryParms &parms)
                         { parms.setDefaults(); }
private:
    IMG_Raster          *myBackgroundImage;
};

#endif

---