OP/OP_Context.h

Go to the documentation of this file.

#ifndef __OP_Context__
#define __OP_Context__

#include "OP_API.h"
#include <SYS/SYS_Types.h>
#include "OP_DataTypes.h"               // For OP_DATA_TYPE
#include "OP_Version.h"                 // For OP_VERSION

#include <stdio.h>

#define OP_TIME_TOL (0.00001)

class OP_CookTask;

class OP_API OP_ContextData
{
public:
    OP_ContextData()            {}
    virtual ~OP_ContextData()   {}
};

class OP_API OP_Context
{
public:
                         OP_Context();
    explicit             OP_Context(double t);
                         OP_Context(double t, int thread);
                         OP_Context(const OP_Context &from);

    double               getTime() const        { return myTime; }
    void                 setTime(double t)      { myTime = t; }

    int                  xres() const   { return myXres; }
    int                  yres() const   { return myYres; }
    void                 setXres(int xres)      { myXres = xres; }
    void                 setYres(int yres)      { myYres = yres; }
    void                 setRes(int x, int y)   { myXres = x; myYres = y; }

    long                 getFrame()   const;
    double               getFloatFrame() const;
    void                 setFrame(long frame);
    void                 setFrame(double frame);

    // The "thread" member is the sequential thread returned by UTgetSTID()
    // (UT_Thread.h) for the current thread.
    void                 setThread(int thr) { myThread = thr; }
    int                  getThread() const  { return myThread; }

    // A cook task will be available when the node is asked to be cooked in
    // parallel.
    void                 setCookTask(OP_CookTask *cook_task)
                            { myCookTask = cook_task; }
    OP_CookTask         *cookTask()
                            { return myCookTask; }
    const OP_CookTask   *cookTask() const
                            { return myCookTask; }

    OP_ContextData      *getData() const                { return myData; }
    void                 setData(OP_ContextData *data)  { myData = data; }

    OP_VERSION           getVersion() const { return myVersion; }
    void                 setVersion(OP_VERSION version) { myVersion = version; }

    bool                 isCookOverride() const
                            { return myFlags.myCookOverride; }
    void                 setCookOverride(bool override)
                            { myFlags.myCookOverride = override; }
    bool                 isTimeDep() const
                            { return myFlags.myTimeDep; }
    void                 setTimeDep(bool timedep)
                            { myFlags.myTimeDep = timedep; }

    void                 copyPointer(const OP_Context &from);

    int                  operator==( const OP_Context &to ) const;
    OP_Context          &operator= ( const OP_Context &to );

    void                 print(FILE *);


                                        // Match criteria.
                                        // These fields define the parameters
                                        // for getCookedData(), or
                                        // needToCook() or cook().
    double               myTime;        // 0 based time
    int                  myXres;        // Pixel resolution
    int                  myYres;        // Pixel resolution


private:

    void                 initDefaults(double t, int thread);

                                        // These fields are used to define the
                                        // kind of COOK or GET that is to take
                                        // place
    OP_VERSION           myVersion;     // When fetching data, this is the
                                        // version number of the fetched data.
    OP_ContextData      *myData;        // User-specific cook data

    int                  myThread;      // UTgetSTID() when this context was
                                        // created.

    OP_CookTask         *myCookTask;    // Current cook task

    // Flags (default value is in square brackets)
    struct Flags
    {
        uint64  myCookOverride:1,       // [false] Cook only if it is quick
                myTimeDep:1;            // [true]  Am I time dependent?
    } myFlags;
};

#endif

---