GB/GB_AttributeData.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 Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This contains the class definition for attribute data
 */

#ifndef __GB_AttributeData_h__
#define __GB_AttributeData_h__

#include "GB_API.h"
#include <stdlib.h>
#include <string.h>
#include <SYS/SYS_Types.h>
#include <SYS/SYS_Math.h>
#include "GB_AttributeRef.h"
#include "GB_AttributeBuffer.h"

class GB_Attribute;
class GB_FloatOffsets;
class GB_VectorOffsets;

#include <UT/UT_VectorTypes.h>

class GB_API GB_AttributeData
{
public:
    GB_AttributeData();
   ~GB_AttributeData();

    //
    //  Get a pointer to the data desired
    //
    void SYS_DEPRECATED *getData(int n) const { return (char *)myData + n; }
    void SYS_DEPRECATED *getData() const { return myData; }

    template<typename T>
    T           *castAttribData(const GB_AttributeRef &n)
                    { return (T *)((char *)myData+n.myHandle); }
    template<typename T>
    const T     *castAttribData(const GB_AttributeRef &n) const
                    { return (T *)((const char *)myData+n.myHandle); }


    void         changeSize(int s) { myData = realloc(myData, (unsigned)s); }
    void         deleteData() { if (myData) free(myData); myData = 0; }

    void SYS_DEPRECATED *operator[](unsigned n) { return (void *)((char *)myData + n); }
    void SYS_DEPRECATED *operator[](unsigned n) const  
                 {
                     return (void *)((char *)myData + n); 
                 }

    //
    //  Add the from attribute information to me.  Optionally, scale
    //          the from data before it's added.
    //  Scaling will simply scale all the data...
    //
    /// @deprecated - Please use addAttributeValues() on GB_AttributeElem
    void         sumData(const GB_AttributeData &from,
                         const GB_Attribute *table, fpreal scale);
    /// @deprecated - Please use addAttributeValues() on GB_AttributeElem
    void         sumData(const GB_AttributeData &from,
                         const GB_Attribute *table);
    /// @deprecated - Please use mulAttributeValues() on GB_AttributeElem
    void         scaleData(const GB_Attribute *table, fpreal s);

    /// @deprecated - Please use copyAttributeValues() on GB_AttributeElem
    void         setData(const GB_AttributeData &from, int s)
                 {
                    memcpy(myData, from.myData, (unsigned)s);
                 }

    void         swapData(GB_AttributeData &d)
                 {
                     void *tmp = myData; myData = d.myData; d.myData = tmp;
                 }

    // Compares two attribute data with a floating point tolerance.
    // Integer compares will not use the tolerance.
    // true if equal, false if different.
    bool        compareData(const GB_AttributeData &cmp,
                        const GB_Attribute *table, 
                        fpreal tol = FP32_TOLERANCE) const;

    // Simple operations applied to the float attributes. TODO: do the same
    // for ints, and provide methods that do not take an offset array.
    void         setf(fpreal val, const GB_FloatOffsets &foffsets);
    void         addf(fpreal val, const GB_FloatOffsets &foffsets);
    void         subf(fpreal val, const GB_FloatOffsets &foffsets);
    void         mulf(fpreal val, const GB_FloatOffsets &foffsets);
    void         divf(fpreal val, const GB_FloatOffsets &foffsets);

    // Methods for attributes of type GB_ATTRIB_VECTOR.  The GB_VectorOffsets
    // should be filled out by using getVectorOffsets().
    void         mulv(const UT_Matrix3 &val, const GB_VectorOffsets &foffsets,
                      int keepLength = 1);

    void         setData(const GB_AttributeData &from,
                         const GB_FloatOffsets &foffsets);

    void         addData(const GB_AttributeData &from, 
                         const GB_FloatOffsets  &foffsets);

    // Scale the data before summing.  Useful for subtracting data,
    // and blending attributes.
    void         addScaleData(const GB_AttributeData &from, 
                         const GB_FloatOffsets  &foffsets, fpreal scale);

    // Interpolates the float attributes at parameter t between a and b.
    void         interpolateData(const GB_AttributeData &a,
                                 const GB_AttributeData &b,
                                 const GB_FloatOffsets  &offsets,
                                 fpreal t);
    
    // Some cheap operators for now:
    int          operator==(const GB_AttributeData &d) const
                 {
                     return this->myData == d.myData;
                 }

    void         steal(GB_AttributeData &v)
                 {
                    myData = v.myData;
                    v.myData = 0;
                 }

    bool         hasData() const { return myData != 0; }

    GB_AttributeData    &operator=(const GB_AttributeData &) { return *this; }

private:
    /// @cond

    /// Effectively a template namespace for access to basic types matching the
    /// storage type (i.e. native).
    template <typename T> class NativeBasicAccessors
    {
    public:
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h, T *buffer,
                                    int count)
                            { return adata.castAttribData<T>(h); }
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h,
                                    GB_AttributeBuffer &buffer, int count)
                            { return adata.castAttribData<T>(h); }
        static T         get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, int index)
                            { return adata.castAttribData<T>(h)[index]; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T &val, int index)
                            { val = adata.castAttribData<T>(h)[index]; }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T &val, int index)
                            { adata.castAttribData<T>(h)[index] = val; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T *val, int count)
                            { adata.read<T, T>(h, val, count); }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T *val, int count)
                            { adata.write<T, T>(h, val, count); }
    };

    /// Effectively a template namespace for access to basic types not matching
    /// the storage type (i.e. non-native), requiring casts.
    template <typename T, typename INTERNAL_T> class NonNativeBasicAccessors
    {
    public:
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h, T *buffer,
                                    int count)
                            {
                                adata.read<INTERNAL_T, T>(h, buffer, count);
                                return buffer;
                            }
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h,
                                    GB_AttributeBuffer &buffer, int count)
                            {
                                return getPointer(adata, h,
#if defined(GCC3) && __GNUC_MINOR__ <= 3
                                            buffer.template asType<T>(count),
#else
                                            buffer.asType<T>(count),
#endif
                                            count);
                            }
        static T         get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, int index)
                            { return
                                adata.castAttribData<INTERNAL_T>(h)[index]; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T &val, int index)
                            { val=adata.castAttribData<INTERNAL_T>(h)[index]; }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T &val, int index)
                            { adata.castAttribData<INTERNAL_T>(h)[index]=val; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T *val, int count)
                            { adata.read<INTERNAL_T, T>(h, val, count); }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T *val, int count)
                            { adata.write<T, INTERNAL_T>(h, val, count); }
    };

    /// Effectively a template namespace for access to POD types consisting of
    /// a simple tuple of a basic type, matching the storage type (i.e. native).
    template <typename T, typename BASIC_T> class NativePODCompoundAccessors
    {
    public:
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h, T *buffer,
                                    int count)
                            { return adata.castAttribData<T>(h); }
        static const T  *getPointer(const GB_AttributeData &adata,
                                    const GB_AttributeRef &h,
                                    GB_AttributeBuffer &buffer, int count)
                            { return adata.castAttribData<T>(h); }
        static T         get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, int index)
                            { return adata.castAttribData<T>(h)[index]; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T &val, int index)
                            { val = adata.castAttribData<T>(h)[index]; }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T &val, int index)
                    { adata.castAttribData<T>(h)[index] = val; }
        static void      get(const GB_AttributeData &adata,
                             const GB_AttributeRef &h, T *val, int count)
                            { adata.read<BASIC_T, BASIC_T>(h, (BASIC_T *)val,
                                        count * sizeof(T) / sizeof(BASIC_T)); }
        static void      set(GB_AttributeData &adata,
                             const GB_AttributeRef &h, const T *val, int count)
                            { adata.write<BASIC_T, BASIC_T>(h,
                                        (const BASIC_T *)val,
                                        count * sizeof(T) / sizeof(BASIC_T)); }
    };
    /// @endcond

    /// @cond

    /// A private template class used to register allowable type parameters for
    /// the public access method templates that follow.
    ///
    /// Explicit specializations of this class follow, each containing a single
    /// Accessors type which behaves effectively as a namespace.
    ///
    /// The non-type FAKE parameter is to ensure the following specializations
    /// are only partial, not full.  Full specializations are not allowed at
    /// class scope.
    template <typename T, int FAKE> class TypeInfo
    {
    };
    /// @endcond

    /// @cond
    template <int FAKE> class TypeInfo<fpreal32, FAKE>
        { public: typedef NativeBasicAccessors<fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<int32, FAKE>
        { public: typedef NativeBasicAccessors<int32> Accessors; };

    template <int FAKE> class TypeInfo<fpreal64, FAKE>
        { public: typedef NonNativeBasicAccessors<fpreal64, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<int64, FAKE>
        { public: typedef NonNativeBasicAccessors<int64, int32> Accessors; };

    template <int FAKE> class TypeInfo<UT_Vector2, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Vector2, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<UT_Vector3, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Vector3, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<UT_Vector4, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Vector4, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<UT_Quaternion, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Quaternion, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<UT_Matrix3, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Matrix3, fpreal32> Accessors; };
    template <int FAKE> class TypeInfo<UT_Matrix4, FAKE>
        { public: typedef NativePODCompoundAccessors<UT_Matrix4, fpreal32> Accessors; };
    /// @endcond

public:

    /// @name Get/Set Accessors For Individual Attributes
    /// @{
    /// @copydoc getPointer()

    /// These template methods can only be instantiated with the following
    /// types:
    ///  fpreal32, fpreal64, int32, int64, UT_Vector[34], UT_Matrix[34]
    ///
    /// @warning These methods assume that the data type for the given
    /// attribute matches the data requested.  It is not safe to call a
    /// version not matching that data type.  The sole exceptions are
    /// fpreal64 and int64, where the underlying data must be of type
    /// fpreal32 and int32, respectively.

    template <typename T>
        const T *getPointer(const GB_AttributeRef &h, T *buffer, int cnt) const
                    { return TypeInfo<T,0>::Accessors::getPointer(
                                            *this, h, buffer, cnt); }
    template <typename T>
        const T *getPointer(const GB_AttributeRef &h,
                            GB_AttributeBuffer &buffer, int cnt) const
                    { return TypeInfo<T,0>::Accessors::getPointer(
                                            *this, h, buffer, cnt); }
    template <typename T>
        T        getValue(const GB_AttributeRef &handle, int index = 0) const
                    { return
                        TypeInfo<T,0>::Accessors::get(*this, handle,index); }
    template <typename T>
        void     get(const GB_AttributeRef &handle, T &val, int index = 0) const
                    { TypeInfo<T,0>::Accessors::get(*this, handle, val,index); }
    template <typename T>
        void     set(const GB_AttributeRef &handle, const T &val, int index = 0)
                    { TypeInfo<T,0>::Accessors::set(*this, handle, val,index); }
    template <typename T>
        void     get(const GB_AttributeRef &handle, T *val, int count) const
                    { TypeInfo<T,0>::Accessors::get(*this, handle, val,count); }
    template <typename T>
        void     set(const GB_AttributeRef &handle, const T *val, int count)
                    { TypeInfo<T,0>::Accessors::set(*this, handle, val,count); }
    /// @}

private:
    /// CopyImpl template is a simple wrapper around a copy function to allow
    /// partial specialization which is not supported by function templates.
    template <typename DST_T, typename SRC_T> struct CopyImpl
    {
        static void      copy(DST_T *dest, const SRC_T *src, int count)
                         {
                             for (int i = 0; i < count; i++)
                                 dest[i] = (DST_T)(src[i]);
                         }
    };
    template <typename T> struct CopyImpl<T,T>
    {
        static void      copy(T *dest, const T *src, int count)
                         {
                             memcpy(dest, src, count*sizeof(T));
                         }
    };

    template <typename SRC_T, typename DST_T>
        void             read(const GB_AttributeRef &handle, DST_T *dest,
                              int count) const
                         {
                             CopyImpl<DST_T, SRC_T>::copy(
                                     dest,castAttribData<SRC_T>(handle),count);
                         }
    template <typename SRC_T, typename DST_T>
        void             write(const GB_AttributeRef &handle, const SRC_T *src,
                               int count)
                         {
                             CopyImpl<DST_T, SRC_T>::copy(
                                     castAttribData<DST_T>(handle), src, count);
                         }

    void        *myData;
};

#endif

---