IFD/IFD_IPRTree.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:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        IFD_IPRTree.h ( IFD Library, C++)
 *
 * COMMENTS:
 */

#ifndef __IFD_IPRTree__
#define __IFD_IPRTree__

#include "IFD_API.h"
#include <UT/UT_String.h>
#include <UT/UT_PtrArray.h>
#include "IFD_IPREvent.h"

class UT_HashTable;
class UT_IStream;
class IFD_IPRObject;
class IFD_IPRObjectFactory;
class IFD_IPRData;
class ROP_IPRObject;
class IFD_RenderStream;
class IFD_StreamEvent;

class IFD_API IFD_IPRTree {
public:
     IFD_IPRTree(const char *cachefile="", const char *cacheprefix="ipr");
    ~IFD_IPRTree();

    int          save(ostream &os);
    bool         load(UT_IStream &is, IFD_IPRObjectFactory &factory,
                      float now);
    void         afterLoad(float now);
    
    void         setRenderer(const char *r)     { myRenderer.harden(r); }
    const char  *getRenderer() const            { return myRenderer; }

    void         setRenderData(IFD_IPRData *rdata);
    IFD_IPRData *getRenderData()        { return myRenderData; }

    // Get the name of the IPR disk file (or memory buffer or whatever)
    const char  *getIPRName()   { return myIPRName; }
    void         setIPRName(const char *name);

    void         setStream(IFD_RenderStream *stream);
    bool         hasStream() const      { return myRenderStream != 0; }

    const char  *getCacheFile() const   { return myCacheFile; }

    bool         startRender(float now);
    bool         finishRender(int status);

    bool        beingCreated() const    { return myBeingCreated; }
    void        forceRecreate()         { myBeingCreated = true; }

    bool        isDirty() const         { return myDirty; }
    void        setDirty(bool onoff);

    void        setDestroyCache(bool onoff);

    void        clearAll();

    bool        lightDirty(int obj, const char *attribute);
    bool        fogDirty(int obj, const char *attribute);
    bool        detailDirty(int obj, const char *attribute);
    bool        instanceDirty(int obj, const char *attribute);

    bool        containsLight(int obj);
    bool        containsFog(int obj);
    bool        containsDetail(int obj);
    bool        containsInstance(int obj);

    // When constructing, these methods will be called to construct the tree.
    // Each of the objects should be able to determine whether attributes of
    // the object have been changed.
    void        addLight(IFD_IPRObject *obj);
    void        addFog(IFD_IPRObject *obj);
    void        addDetail(IFD_IPRObject *obj);
    void        addInstance(IFD_IPRObject *obj);

    // Add lights or fogs that were not originally present in the pre-render.
    // These objects will be recreated for each rerender.
    void        addNewLight(IFD_IPRObject *obj);
    void        addNewFog(IFD_IPRObject *obj);

    // During re-rendering, it's important to be able to find objects in the
    // list.
    IFD_IPRObject       *findLight(int unique_id);
    IFD_IPRObject       *findFog(int unique_id);
    IFD_IPRObject       *findInstance(int unique_id);
    IFD_IPRObject       *findDetail(int unique_id);
    ROP_IPRObject       *findRopLight(int unique_id);
    ROP_IPRObject       *findRopFog(int unique_id);
    ROP_IPRObject       *findRopInstance(int unique_id);
    ROP_IPRObject       *findRopDetail(int unique_id);

    // Prior to the tree being used a mapping needs do be created from the
    // IFD_Scene mapping of objects to the objects involved.
    int         getLightCount() const   { return myLights.entries(); }
    int         getFogCount()   const   { return myFogs.entries(); }
    int         getDetailCount() const  { return myDetails.entries(); }
    int         getInstanceCount() const { return myInstances.entries(); }

    IFD_IPRObject       *getLight(int i)        { return myLights(i); }
    IFD_IPRObject       *getFog(int i)          { return myFogs(i); }
    IFD_IPRObject       *getDetail(int i)       { return myDetails(i); }
    IFD_IPRObject       *getInstance(int i)     { return myInstances(i); }

    /// Each object has a flag stating whether it's used in the re-rendering or
    /// not.  This method clears all the flags for all the objects.
    void                 clearObjectUsedFlags();

    /// A map is created which maps the index in the scene to an object in the
    /// IPR tree.  These maps are created when re-rendering the scene.
    void                 allocateMaps(int nlight, int nfog,
                                      int ndetail, int ninstances);
    void                 freeMaps();

    int                 *getLightMap()    { return myLightMap; }
    int                 *getFogMap()      { return myFogMap; }
    int                 *getDetailMap()   { return myDetailMap; }
    int                 *getInstanceMap() { return myInstanceMap; }

    int                  getLightMapSize()      { return myLightMapSize; }
    int                  getFogMapSize()        { return myFogMapSize; }
    int                  getDetailMapSize()     { return myDetailMapSize; }
    int                  getInstanceMapSize()   { return myInstanceMapSize; }

    void                 dump();

    bool                 autogenDirty() const   { return myAutoGenDirty; }
    void                 dirtyAutogen()         { myAutoGenDirty = true; }

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

private:
    void                buildHashTables();
    void                handleStreamEvent(IFD_StreamEvent &event);

    UT_String                            myIPRName;
    UT_String                            myCacheFile;
    UT_String                            myRenderer;
    IFD_IPRData                         *myRenderData;
    IFD_RenderStream                    *myRenderStream;

    UT_PtrArray<IFD_IPRObject *>        myLights;
    UT_PtrArray<IFD_IPRObject *>        myFogs;
    UT_PtrArray<IFD_IPRObject *>        myDetails;
    UT_PtrArray<IFD_IPRObject *>        myInstances;
    UT_PtrArray<IFD_IPRObject *>        myNewLights;
    UT_PtrArray<IFD_IPRObject *>        myNewFogs;
    UT_NotifierImpl<IFD_IPREvent &>     myEventNotifier;
    UT_NotifierList                     myNotifierList;

    UT_HashTable                        *myHashTable;
    UT_HashTable                        *myInstanceHash;
    UT_HashTable                        *myDetailHash;

    int                                 *myLightMap;
    int                                 *myFogMap;
    int                                 *myDetailMap;
    int                                 *myInstanceMap;

    int                                  myLightMapSize;
    int                                  myFogMapSize;
    int                                  myDetailMapSize;
    int                                  myInstanceMapSize;

    bool                                 myDirty;
    bool                                 myBeingCreated;
    bool                                 myTempCache;
    bool                                 myDestroyCache;
    bool                                 myPipeStream;
    bool                                 myAutoGenDirty;
    bool                                 myLoadedFromFile;
    int                                  myPendingStreams;
};

#endif

---