GOP/GOP_VexContext.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:
 *      Eran Guendelman
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GOP_VexContext.h ( GVEX Library, C++)
 *
 * COMMENTS:    Contains a context for evaluating POP/SOP vex functions
 */

#ifndef __GOP_VexContext__
#define __GOP_VexContext__

#include "GOP_API.h"
#include <UT/UT_Dependency.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_StringArray.h>
#include <VEX/VEX_Instance.h>
#include <VEX/VEX_ContextManager.h>
#include <VEX/VEX_Context.h>
#include <VEX/VEX_DataCache.h>

class VEX_StringSet;
class GVEX_Map;

typedef enum {
    GOP_POS,            // position
    GOP_POSW,           // point's w() component
    GOP_VEL,            // velocity
    GOP_ACCEL,          // acceleration
    GOP_AGE,            // age
    GOP_LIFE,           // life expectancy
    GOP_PSTATE,         // state
    GOP_ID,             // id
    GOP_PTNUM,          // point number
    GOP_COLOR,          // point color
    GOP_NORMAL,         // point normal

    GOP_NPT,            // number of particles
    GOP_TIME,           // current time
    GOP_FRAME,          // current frame
    GOP_TIMEINC,        // time step size
    
    GOP_MAX_VARIABLES
} GOP_Global;

class GB_PointGroup;
class GEO_Point;
class GU_Detail;
class VEX_ProcArray;
class GVEX_Atlas;
class UT_Vector3;
class UT_Vector4;
class UT_Matrix3;
class UT_Matrix4;

DECLARE_DEPENDENCY(GOP)

class GOP_API GOP_VariableMap {
public:
     GOP_VariableMap();
    ~GOP_VariableMap();


    // Initialize has to be called once to find out what variables are
    // required by the function
    void         initData(VEX_Instance *func);

    // Must be called after initData.  Returns 1 if the VEX_Instance
    // initialized with initData reads a time dependent variable
    int          isTimeDep();

    // Must be called after initData.  Returns 1 if the VEX_Instance
    // initialized with initData makes any reference to the
    // object-world transformation (using functions such as ow_space, etc.)
    // If the transformation is referenced, we have to make sure that we
    // re-cook if the underlying transformation changes.
    int          isObjXformDep();

    void         initExports(GU_Detail *gdp);

    // Binding should be done each time you evaluate the function
    void         bind(VEX_Instance *func);
    void         bindAtlas(const GVEX_Atlas *atlas,
                           VEX_Instance *func,
                           VEX_ProcArray *proc);

    // Put data into myData
    void         prepData(GU_Detail *gdp, const GB_PointGroup *ptgroup,
                          UT_StringArray &groupnames,
                          int numPoints, float time, float frame, float timeinc);
    void         prepData(VEX_ProcArray *proc);
    void         prepData(GEO_Point *ppt, int index);

    // Extract data
    void         extractData(VEX_ProcArray *proc);

    // Done (called after the VEX function has been called on all of the
    // points)
    void         done(GU_Detail *gdp, bool last_thread);

    // These are used by the GOP_Function's to handle point groups
    GB_PointGroup       *newGroup(const char *groupName);
    void                 getBoundingBox(UT_Vector3 &xlate, UT_Vector3 &scale);
    void                 getBoundMinMax(UT_Vector3 &min, UT_Vector3 &max);

    void                 setComputeNormal(int onoff)
                         {
                             myRecomputeNormal = onoff;
                         }

    void                 clearInputs();
    void                 setInput(int idx, const GU_Detail *gdp);
    const GU_Detail     *getInput(int idx) const;
    const GEO_Point     *getPoint(int idx) const { return myPoints[idx]; }
    GEO_Point           *getPoint(int idx)       { return myPoints[idx]; }

    // Can return 0 if no such ring (no input, no point, etc)
    UT_PtrArray<GEO_Point *>    *getRingZero(int ptnum, int input=0);
    // Delete all allocated rings.
    void                         clearRingZeros();

    GU_Detail                           *myDetail;

private:
    void        *getData(GOP_Global id)
                 { return myMap[id] >= 0 ? myData[id] : 0; }

    UT_PtrArray<const GU_Detail *>       myInputs;

    // Can only call these functions after initData when myFunc gets set
    int  isRead(GOP_Global id)
         { return myMap[id] >= 0 ? myFunc->isRead(myMap[id]) >= 0 : 0; }
    int  isWritten(GOP_Global id)
         { return myMap[id] >= 0 ? myFunc->isWritten(myMap[id]) >= 0 : 0; }

    void        updateBoundingBox();
    void        fillAttrib(char *data, int offset, int size, int npts);
    void        fillAttribVal(char *data, char *val, int size, int npts);
    void        fillStringAttrib(VEX_StringSet *set,
                            const GVEX_Map *map, int npts);
    void        extractAttrib(char *data, int offset, int size, int npts, int
                            uniform = 0);
    void        extractString(const VEX_StringSet *ss, const char *name,
                                int npts, int uniform=0);

    VEX_DataCache        myDataCache;
    int                  myAttrOffset[GOP_MAX_VARIABLES];
    int                  myMap [GOP_MAX_VARIABLES];
    void                *myData[GOP_MAX_VARIABLES];
    VEX_Instance        *myFunc;
    GEO_Point           **myPoints;
    UT_StringArray      *myGroupNames;
    int                  myDestroyNormal;
    const GB_PointGroup *myPointGroup;

    int                  myBBoxUpdated;
    UT_Vector3           myBBoxMin;
    UT_Vector3           myBBoxMax;
    UT_Vector3           myBBoxScale;

    UT_IntArray          myExports;
    UT_IntArray          myPointMap;

    // Member data to store global uniform variables
    int                  myNumPts;
    float                myTime;
    float                myFrame;
    float                myTimeInc;
    unsigned int         myRecomputeNormal:2,
                         myUpdateW:1;
    
    // Cached rings:  myRingCache(inputnum)(pointnum)(ringentry).
    UT_PtrArray<UT_PtrArray<UT_PtrArray<GEO_Point *> *> *>      myRingCache;
};

class GOP_API GOP_VexContext : public VEX_Context {
public:
    static const char   **getRequiredVariables();

    virtual int          getGlobalVariableEntries() const;
    virtual const char  *getGlobalVariableName(int id) const;
    virtual const char  *getGlobalVariableDescription(int id) const;
    virtual VEX_Type     getGlobalVariableType(int id) const;
    virtual VEX_Storage  getGlobalVariableStorage(int id) const;
    virtual int          getGlobalVariableReadWrite(int id) const;

private:
             GOP_VexContext(const char *name, int path);
    virtual ~GOP_VexContext();

    static VEX_Context  *getPopContext();
    static void          clearPopContext();

    static VEX_Context  *getSopContext();
    static void          clearSopContext();

    virtual void         addGlobalVariables(VEX_Assemble &as) const;

    friend class GOP_DummyFriend; // to avoid private d-tor warnings

    VEX_DECLARE_CONTEXT(VEX_POP_CONTEXT)
    VEX_DECLARE_CONTEXT(VEX_SOP_CONTEXT)
};

#endif

---