CVEX/CVEX_Value.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_Value.h ( CVEX Library, C++)
 *
 * COMMENTS:    C++ interface to VEX.  This class is used to specify
 *              input/output variable data.
 */

#ifndef __CVEX_Value__
#define __CVEX_Value__

#include "CVEX_API.h"

class UT_StringArray;

/// The CVEX_Type enum defines the VEX types available to CVEX.
typedef enum {
    CVEX_TYPE_INVALID = -1,     // Invalid type
    CVEX_TYPE_INTEGER,          // 32 bit integer
    CVEX_TYPE_FLOAT,            // 32 bit float
    CVEX_TYPE_VECTOR3,          // 3-tuple of 32 bit float
    CVEX_TYPE_VECTOR4,          // 4-tuple of 32 bit float
    CVEX_TYPE_MATRIX3,          // 9-tuple of 32 bit float
    CVEX_TYPE_MATRIX4,          // 16-tuple of 32 bit float
    CVEX_TYPE_STRING            // string values
} CVEX_Type;

/// @brief A class representing a VEX value.
///
/// The CVEX_Value objects are created internally in the CVEX library.  They
/// provide a mapping from the CVEX library to the underlying VEX
/// representation of objects.
class CVEX_API CVEX_Value {
public:
     CVEX_Value(const char *name, CVEX_Type type, bool varying);
    ~CVEX_Value();

    /// Query name of VEX value
    const char  *getName() const        { return myName; }
    /// Query type of VEX value
    CVEX_Type    getType() const        { return myType; }
    /// Query whether the VEX value is an export (or read-only)
    bool         isExport() const       { return myExport; }
    /// Query whether the VEX value is uniform or varying
    bool         isVarying() const      { return myVarying; }
    /// Query the array size of the VEX value.
    /// @note This is @b not the used for VEX arrays, but rather represents the
    /// number of entries in the varying array.
    int          getArraySize() const   { return myArraySize; }

    /// Get the raw data pointer.
    /// For numeric types, the data refers to a raw array of data (depending on
    /// the getType() of the value.
    /// - CVEX_TYPE_INTEGER     @c int
    /// - CVEX_TYPE_FLOAT       @c fpreal32
    /// - CVEX_TYPE_VECTOR3     @c UT_Vector3
    /// - CVEX_TYPE_VECTOR4     @c UT_Vector4
    /// - CVEX_TYPE_MATRIX3     @c UT_Matrix3
    /// - CVEX_TYPE_MATRIX4     @c UT_Matrix4
    /// For CVEX_TYPE_STRING, the data will point to a UT_StringArray.
    void        *getData()              { return myData; }

    /// The array size is NOT the size in bytes, but rather the array size of
    /// the input data.  It should either be 1 or N, where N is the number of
    /// values being computed by VEX.
    ///
    /// When passing data for output variables, please check to see whether
    /// the output variable is uniform or varying.  Varying values need to
    /// have a full array of data (including string arrays).
    ///
    /// The CVEX_Value object will hold a pointer to the UT_StringArray, so the
    /// data must be persistent.
    bool         setData(void *data, int array_size);

    /// When setting values for string types, you need to pass in a
    /// UT_StringArray instead of a void *.  For input variables, the length
    /// of the array will determine whether the parameter is varying or
    /// uniform.
    ///
    /// The CVEX_Value object will hold a pointer to the UT_StringArray, so the
    /// data must be persistent.
    bool         setData(UT_StringArray &stringdata);

private:
    static int          cvexToVexType(CVEX_Type type);
    static CVEX_Type    vexToCVexType(int vextype);

    void        *myData;
    const char  *myName;
    CVEX_Type    myType;        // Data type
    int          myVexType;     // VEX Type (mapped from CVEX_Type)
    int          myVexIndex;    // Offset into VEX symbol table
    int          myArraySize;   // Array size
    bool         myExport;      // Whether the data is output by VEX
    bool         myVarying;     // Whether the data is varying

    friend class        CVEX_Context;
};

#endif

---