ROP/ROP_RenderItem.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 Alexander
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        ROP_RenderItem.h ( ROP Library, C++)
 *
 * COMMENTS:
 *    Defines a simple structure to describe what and how to render a ROP.
 */
#ifndef ROP_RenderItem_h
#define ROP_RenderItem_h

#include "ROP_API.h"

#include <UT/UT_FloatArray.h>
#include "ROP_Node.h"

class ROP_API ROP_RenderItem
{
public:
    ROP_RenderItem(ROP_Node *node) : myNode(node)
        {
            mySingleFrame = false;
            myStartFrame = myEndFrame = 0.0f;
            myFrameInc = 1.0f;
            myRegularSequence = true;
            myRenderId = ++ourRenderIdCount;
        }

    // methods to set the frame range
    void         setSingleFrame(float frame)
                 { mySingleFrame = true; myEndFrame = myStartFrame = frame; }
    
    void         setFrameRange(float start,float end, float finc);

    // calling will render the ROP attached to this object.
    bool         render(ostream *verbose=0, int count=0, int total=0) const;

    // returns true if 'item' would be covered by this ROP, making it a
    // duplicate entry.
    bool         containedBy(const ROP_RenderItem &item);

    // removes any overlapping frames. This should be called after contains(),
    // which will remove any total overlaps.
    void         removeOverlap(const ROP_RenderItem &item);

    bool         mergeWith(const ROP_RenderItem &item);


    // dump the render information to os.
    void         print(ostream &os, bool full_path, bool condense_range) const;

    // returns the number of frames that would be rendered by this item
    int          getNumFrames() const;

    // accessors
    ROP_Node    *getNode() const        { return myNode; }
    bool         isSingleFrame() const  { return mySingleFrame; }
    float        getFrame() const       { return myStartFrame; }
    float        getStartFrame() const  { return myStartFrame; }
    float        getEndFrame() const    { return myEndFrame; }
    float        getFrameInc() const    { return myFrameInc; }

    // a regular sequence is something that can be represented by
    // start/end/finc. However, in removeOverlap(), removing overlapping
    // frames may create a non-regular sequence, in which case, we need to
    // render the frames individually.
    bool         isRegularSequence() const { return myRegularSequence; }
    const UT_FloatArray &getFrameList() const { return myFrames; }


    // Resets the render ids so that they start back at the beginning.  Be
    // careful where you call this from.
    static void   resetRenderIds() { ourRenderIdCount = 0; }

    int           getRenderId() const { return myRenderId; }

    // Adds an item as a dependency, which means that this item must render
    // before we do.
    void          addDependency(const ROP_RenderItem &item) const;

    // Take the dependencies of item and add them to our list
    void          mergeDependencies(const ROP_RenderItem &item);

    // Goes through our dependents and make them depend on with_item instead
    // of this item.
    void          replaceDependencies(const ROP_RenderItem &with_item);

private:
    ROP_Node    *myNode;
    bool         mySingleFrame;
    bool         myRegularSequence;
    float        myStartFrame;
    float        myEndFrame;
    float        myFrameInc;
    UT_FloatArray myFrames;

    int          myRenderId;

    // This is the list of direct items that have to be rendered before this 
    // item.  This list is usually very small.
    mutable UT_PtrArray<const ROP_RenderItem *> myDependencies;

    // This is the list of direct items that have to be rendered after this
    // item.  This list is usually very small.
    mutable UT_PtrArray<const ROP_RenderItem *> myDependents;


    static int   ourRenderIdCount;
};

#endif

---