COP2/COP2_VexOp.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:        COP2_VexOp.h ( Channel Operator Library, C++)
 *
 * COMMENTS:
 *
 *      Class that both COP2_Vex and COP2_VexScript are derived from.
 */

#ifndef __COP2_VexOp__
#define __COP2_VexOp__

#include "COP2_API.h"
#include <UT/UT_IntArray.h>
#include <TIL/TIL_Defines.h>
#include <VEX/VEX_Error.h>
#include <OP/OP_Error.h>

#include "COP2_Context.h"

class VEX_Instance;
class VEX_ProcArray;
class VEX_LateBinding;
class COP2_VexVariableMap;
class COP2_VexAtlas;
class cop2_VexData;
class COP2_CookAreaInfo;
class COP2_CookAreaList;
class OP_Caller;
class OP_Node;

class COP2_API COP2_VexOp 
{
public:

    void                 runVexSetup(TIL_Sequence &seq, OP_ERROR &error);

    static TIL_FastLock &getVexLock();

protected:
                         COP2_VexOp(COP2_Node *mycop);
    virtual             ~COP2_VexOp();

    void                 getVexContext(cop2_VexData *vdata,
                                       const TIL_Sequence &sequence,
                                       UT_PtrArray<const TIL_Sequence *> &in,
                                       const TIL_Plane *, int,
                                       float t, int xres,int yres, int thread);
    
    OP_ERROR             cookVex(COP2_Context &context,
                                 TIL_TileList *tiles, 
                                 TIL_Sequence &seq);

    void                 clearFunctions();

    void                 getOutputAreas(COP2_Context &context,
                                        const TIL_Sequence &seq,
                                        COP2_CookAreaInfo &output_area,
                                        const COP2_CookAreaList &input_areas,
                                        COP2_CookAreaList &needed_areas);

    // must define a function to get at the string parm.
    virtual void         getVexScript(UT_String &string, float t,
                                      int thread) = 0;
    virtual bool         isVexFilter() const = 0;
            bool         isTimeRead() const { return myTimeRead; }
    
    void                 compute(UT_String &script);
    void                 fillData(int x,int y, int xsize, int ysize,
                                  const TIL_Tile *rtile, float *rdata,
                                  const TIL_Tile *gtile, float *gdata,
                                  const TIL_Tile *btile, float *bdata,
                                  const TIL_Tile *atile, float *adata,
                                  const TIL_Tile *c1tile, float *c1data,
                                  const TIL_Tile *c2tile, float *c2data,
                                  const TIL_Tile *c3tile, float *c3data,
                                  const TIL_Tile *c4tile, float *c4data);

    void                 extractData(int x,int y, int xsize, int ysize,
                                     TIL_Tile *rtile, const float *rdata,
                                     TIL_Tile *gtile, const float *gdata,
                                     TIL_Tile *btile, const float *bdata,
                                     TIL_Tile *atile, const float *adata,
                                     TIL_Tile *c1tile, const float *c1data,
                                     TIL_Tile *c2tile, const float *c2data,
                                     TIL_Tile *c3tile, const float *c3data,
                                     TIL_Tile *c4tile, const float *c4data);

    void                 initRGBATiles(const TIL_TileList *tilelist,
                                       TIL_Tile *c1tile, TIL_Tile *c2tile,
                                       TIL_Tile *c3tile);

    VEX_Instance                        *myStaticFunc;
    COP2_VexVariableMap                 *myStaticMap;
    UT_String                            myLastStaticFunction;
    VEXerrorHandler                     myPrevErrorHandler;
    VEXerrorHandler                     myPrevWarnHandler;

    unsigned                            myNeedInputRGB : 1,
                                        myNeedInputA   : 1,
                                        myNeedInputComp: 1,
                                        myWriteR       : 1,
                                        myWriteG       : 1,
                                        myWriteB       : 1,
                                        myWriteA       : 1,
                                        myWriteC1      : 1,
                                        myWriteC2      : 1,
                                        myWriteC3      : 1,
                                        myWriteC4      : 1,
                                        myTimeRead     : 1;
    
    COP2_VexAtlas                       *myAtlas;
    VEX_LateBinding                     *myBinding;
    UT_IntArray                         myExports;
    UT_IntArray                         myExportPlanes;
    COP2_Node                           *myCop;
    OP_VERSION                          myFuncVersion;
};

class COP2_API cop2_VexData : public COP2_ContextData
{
public:
                 cop2_VexData();
    virtual     ~cop2_VexData();
    
    virtual bool createPerThread() const { return true; }
    virtual bool createPerPlane() const { return true; }

    void                 setCaller(OP_Node *caller);
   
    VEX_ProcArray       *myProc;
    VEX_Instance        *myFunction;
    COP2_VexVariableMap *myMap;
    COP2_VexAtlas       *myAtlas;
    OP_Caller           *myCaller;

    UT_String            myLastFunction;
    bool                 myInitFlag;
};

#endif

---