GB/GB_GenericData.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:
 *      George ElKoura
 *      Side Effects Software, Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GB_GenericData.h (C++)
 *
 * COMMENTS:    This class abstracts away a vector of data that you can
 *              write to and read from using whatever type you prefer.  It will
 *              automatically do the correct casting.
 *
 */
#ifndef __GB_GenericData_h__
#define __GB_GenericData_h__

#include "GB_API.h"
#include <SYS/SYS_Types.h>

#include "GB_AttributeDefines.h"
#include "GB_AttributeElem.h"

#include <UT/UT_Vector2.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
class UT_String;
class UT_Quaternion;

class GB_GenericDataIndex;

class GB_API GB_GenericData
{
public:

     GB_GenericData();
    ~GB_GenericData();

    /// Sets the storage type and size of this data.  A pointer to an initial
    /// chunk of data can also optionally be set.
    void                setData(GB_Attribute *attrib,
                                GB_AttributeStorage storage, 
                                int vectorsize, void *data = NULL,
                                bool readonly = false);

    /// Sets the storage type and size of this data to match that of src.
    /// The data pointer will not be copied over however.  Any data will be
    /// flushed in this object before it is no longer referenced.
    void                      copyDefinition(const GB_GenericData &src);

    /// Sets the pointer to the raw data, you must set the size and storage
    /// type before you can call this.
    void                      setDataPointer(void *data, bool readonly);

    /// Sets the pointer to the raw const data (and sets it read only).  The
    /// const is cast away internally when we perform this set.  But the data
    /// is flagged as read-only.
    void                setDataPointer(const void *);

    /// Returns true if this object contains valid data.
    bool                      isValid() const;

    /// Returns the size of this data.
    int                       entries() const { return myVectorSize; }

    /// Accessors
    void                     setF(fpreal val, int index=0);
    fpreal                   getF(int index=0) const;

    void                     setI(int val, int index=0);
    int                      getI(int index=0) const;

    void                setV2(const UT_Vector2 &val, int idx=0);
    UT_Vector2          getV2(int idx=0) const;

    void                     setV3(const UT_Vector3 &val, int index=0);
    UT_Vector3               getV3(int index=0) const;

    void                     setV4(const UT_Vector4 &val, int index=0);
    UT_Vector4               getV4(int index=0) const;

    /// p4 will return a 4th component of 1 if it does not exist
    void                     setP4(const UT_Vector4 &val, int index=0);
    UT_Vector4               getP4(int index=0) const;

    void                     setQ(const UT_Quaternion &val, int index=0);
    UT_Quaternion            getQ(int index=0) const;

    void                setM3(const UT_Matrix3 &m, int index=0);
    UT_Matrix3          getM3(int index=0) const;

    void                setM4(const UT_Matrix4 &m, int index=0);
    UT_Matrix4          getM4(int index=0) const;

    // This method will return a pointer to an object of type T that is
    // stored in this attribute.
    template<typename T> T  *getPointer(int index=0) 
                             { 
                                 if (isValid())
                                     return &(((T *)myRawData)[index]);
                                 else
                                     return (T *)(NULL);
                             }
    template<typename T> 
    const T                 *getPointer(int index=0) const
                             {
                                 if (isValid())
                                     return &(((T *)myRawData)[index]);
                                 else
                                     return (T *)(NULL);
                             }



    /// The {get,set}String methods return true if the attribute represents a
    /// valid string attribute, and false otherwise.
    bool                     setString(const UT_String &str, int index=0);
    bool                     getString(UT_String &str, int index=0,
                                        bool harden=true) const;

    /// The beginIterator() methods return an index type that you can use
    /// to access components in this data sequentially.
    GB_GenericDataIndex      beginIterator() const;
    GB_GenericDataIndex      beginIterator();

    /// Unary arithmetic operations
    void                multiply(fpreal val);
    void                setValue(fpreal val);

    /// Transforming data by matrices.
    /// This uses the type information on the attribute to do the right kind of
    /// transform.
    //
    // TODO: In the long run, we should have transformP(), transformV() and
    // transformN() functions.
    //
    void                transform(const UT_Matrix4 &xform,
                                  const UT_Matrix4 &inverse,
                                  bool keep_lengths=false);

    /// Binary arithmetic operations
    void                addScale(const GB_GenericData &d, fpreal scale);

    /// Multiply/Divide data by the other data
    void                multiply(const GB_GenericData &d);
    void                divide(const GB_GenericData &d);

    /// Performs the operation: this = SYSlerp(this, d, w)
    void                lerp(const GB_GenericData &d, fpreal w);
    void                lerp(const GB_GenericData &d0,
                                const GB_GenericData &d1,
                                fpreal weight);

    template<typename T> bool   import(T &result) const
                        { return GVEXimportData(*this, result); }

    /// Data manipulation
    bool                     equalData(const GB_GenericData &src,
                                        fpreal64 tol) const;

    /// The following copyData methods assume that the supplied data pointers
    /// exactly match the configuration of our data.
    void                     copyDataFrom(const GB_GenericData &src);
    void                     copyDataFrom(const void *src);
    void                     copyDataTo(void *dest) const;

    /// Resets the value of the data to 'uninitialized'.  For most types of
    /// attributes, this is zero, for others it is -1.
    void                     resetData();

    /// Writes out the changes to the attribute data.  Calling this
    /// unnecessarily will have a significant impact on performance.
    void                     flush() const;

    /// This accessor to the GB_Attribute is not to be used.  It's only purpose
    /// is backwards compatibility with functions that have not yet been 
    /// converted to use GB_AttributeHandle instead of GB_Attribute.
    const GB_Attribute      *getAttribute() const { return myAttribute; }
    GB_Attribute            *getAttribute()       { return myAttribute; }



protected:
    /// Returns our size in bytes 
    int64                    sizeInBytes() const;

private:
    int                              myVectorSize;

    GB_AttributeStorage              myRawStorage;
    void                            *myRawData;

    // This is the attribute that is represented by this data.  This is
    // needed primarily for the index string attributes.
    GB_Attribute                    *myAttribute;

    // This is a flag for debugging, set to make sure that we are not
    // writing to data that we intend to have as read-only.
    bool                             myReadOnly;
};

template<typename T>
static inline bool
GVEXimportData(const GB_GenericData &data, T &result)
{ return false; }


// For compilers that need templated function specializations to have
// storage qualifiers, we need to declare the specializations as static inline.
// Otherwise, we'll get linker errors about multiply defined symbols.
#ifdef NEED_SPECIALIZATION_STORAGE
    #define STATIC_INLINE_SPECIALIZATION static inline
#else
    #define STATIC_INLINE_SPECIALIZATION
#endif

#define GVEX_IMPORT_SPECIALIZATION(TYPE, METHOD)        \
    template<> STATIC_INLINE_SPECIALIZATION bool \
    GVEXimportData(const GB_GenericData &data, TYPE &result) \
    { result = data.METHOD; return true; }

GVEX_IMPORT_SPECIALIZATION(int, getI(0) )
GVEX_IMPORT_SPECIALIZATION(fpreal32, getF(0) )
GVEX_IMPORT_SPECIALIZATION(fpreal64, getF(0) )
GVEX_IMPORT_SPECIALIZATION(UT_Vector2, getV2() )
GVEX_IMPORT_SPECIALIZATION(UT_Vector3, getV3() )
GVEX_IMPORT_SPECIALIZATION(UT_Vector4, getV4() )
GVEX_IMPORT_SPECIALIZATION(UT_Matrix3, getM3() )
GVEX_IMPORT_SPECIALIZATION(UT_Matrix4, getM4() )

#undef STATIC_INLINE_SPECIALIZATION

#endif

---