CVEX/CVEX_Context.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:        CVEX_Context.h ( CVEX Library, C++)
 *
 * COMMENTS:    C++ interface to VEX.  This class defines a parameter to the
 *              VEX function.
 *
 */

#ifndef __CVEX_Context__
#define __CVEX_Context__

#include "CVEX_API.h"
#include "CVEX_ValueList.h"

class cvex_RunData;
class UT_OpCaller;

class CVEX_API CVEX_Context {
public:
     CVEX_Context();
    ~CVEX_Context();

    // clearing the context will allow you to set up the input and output
    // parameters again.  load() must be called again before you can run the
    // VEX code.
    void        clear();

    // calling reloadAllVEX() will force all CVEX object code to be flushed out
    // of memory and to be reloaded.  Be cautioned that this may have
    // side-effects, and should only be called at a safe time.  This will also
    // cause *all* functions to be cleared() (see above).
    static void clearAllFunctions();

    //
    // Add possible input parameters to the function.  These are parameters
    // whose values are overridden by values you pass in.
    // If it's relatively expensive to compute a value, you can postpone
    // computation until after you know whether the value will actually be
    // used by the function loaded.
    bool        addInput(const char *name, CVEX_Type type, bool varying);

    // If you know the value beforehand, you can add the symbol and it's
    // value at the same time.
    bool        addInput(const char *name, CVEX_Type type,
                            void *data, int array_size);
    bool        addInput(const char *name, UT_StringArray &strings);

    // Set the evaluation time.  This is what will be used by
    // op: references triggered by VEX commands like volumesample.
    // If not set, the current channel time is used instead.
    void        setTime(float time);

    // Load the VEX function.  This is done AFTER the input parameters have
    // been specified.  After loading, the input list will have flags set
    // telling you whether the input parameter is used.  At this point, you
    // can compute data if you choose.  The list of outputs will also be
    // defined, meaning that you can figure out what's going to be written by
    // the VEX function.
    //
    // If errors occured in loading they are added to the
    // current vex error manager (see VEX_Error.h).
    //
    // NOTE: If no error manager is set, the default behaviour is to
    // exit the program!
    bool        load(int argc, char *argv[]);
    bool        load(int argc, char *argv[], int threadid);

    // Quick test to see if the function has been loaded.
    bool        isLoaded() const        { return myRunData != 0; }

    // The list of input parameters to the function.  It's possible that
    // these values may be shared between the input and output lists.
    CVEX_ValueList      &getInputList()         { return myInputs; }
    CVEX_Value          *findInput(const char *name, CVEX_Type type)
                         { return myInputs.getValue(name, type); }

    // The list of output parameters from the function.  After the function
    // has been run, the output parameters will have their values written to
    // by VEX.
    CVEX_ValueList      &getOutputList()        { return myOutputs; }
    CVEX_Value          *findOutput(const char *name, CVEX_Type type)
                         { return myOutputs.getValue(name, type); }

    // Sets our op callback.  This is used to setup dependencies on
    // any referenced op: expressions.  Can be applied to the context
    // at any time.
    void                 setOpCaller(UT_OpCaller *caller);

    // Gets and clears the VEX_Instance flags on the underlying instance.
    // This can only be done after the vex function has been successfully
    // loaded.
    bool                 getFlag(int flag) const;
    void                 clearFlag(int flag);

    // Run the VEX function given a list of input variables and a list of
    // output parameters.  Each input/output parameter under your control
    // should have an array size of either 1 or at least the array_size given
    // to the run() method.  It's possible to run on fewer array elements
    // than have been allocated, but an error will be returned if there are
    // input parameters which don't have enough allocation.
    //
    // Pass in true for interruptable when running from within Houdini.
    //
    // The run() function may be called multiple times, provided that the
    // input parameters don't change.  So, if you need to evaluate the data
    // in chunks, you can do this by re-initializing the input parameter data
    // between calls to run().  However, you should not change the
    // uniform/varying state of any input parameters without doing a re-load
    // of the VEX function.
    bool        run(int array_size, bool interruptable);

private:
    bool                 bindData(CVEX_Value &value);
    void                 moveData(CVEX_Value &value,
                                        int start, int nproc);
    void                 extractStrings(CVEX_Value &value,
                                        int start, int nproc);
    void                 unbindData(CVEX_Value &value);

    CVEX_ValueList       myInputs;
    CVEX_ValueList       myOutputs;
    cvex_RunData        *myRunData;
    UT_OpCaller         *myOpCaller;
    bool                 myTimeSpecified;
    fpreal               myTime;
};

#endif

---