GB/GB_AttributeBuffer.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:        GB_AttributeBuffer.h ( GB Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GB_AttributeBuffer__
#define __GB_AttributeBuffer__

#include "GB_API.h"

#include <SYS/SYS_Types.h>

#define GB_ATTRIBBUF_INITIAL_8B_SIZE    16

#define GB_ATTRIBBUF_INITIAL_SIZE_F64   (GB_ATTRIBBUF_INITIAL_8B_SIZE)
#define GB_ATTRIBBUF_INITIAL_SIZE_F32   (GB_ATTRIBBUF_INITIAL_8B_SIZE * 2)
#define GB_ATTRIBBUF_INITIAL_SIZE_I64   (GB_ATTRIBBUF_INITIAL_8B_SIZE)
#define GB_ATTRIBBUF_INITIAL_SIZE_I32   (GB_ATTRIBBUF_INITIAL_8B_SIZE * 2)
#define GB_ATTRIBBUF_INITIAL_SIZE_PTR   (GB_ATTRIBBUF_INITIAL_8B_SIZE * 8 / sizeof(void *))

#include <UT/UT_VectorTypes.h>

/// @brief This class provides a convenient temporary buffer for attribute
/// data without the need to worry about memory management.
///
/// This class is intended primarily as an abstraction of a temporary data
/// buffer, and as such, does NOT preserve data across memory reallocation.
class GB_API GB_AttributeBuffer {
public:
    /// Default constructor
    GB_AttributeBuffer() : myHeapBuffer(0), myHeapBufferSize(0) { }

    /// Destructor
    ~GB_AttributeBuffer() { if (myHeapBuffer) delete []myHeapBuffer; }

    fpreal64            *asF64(int count)
                         { 
                             if (count <= GB_ATTRIBBUF_INITIAL_SIZE_F64)
                                 return myStackBuffer.myF64;
                             else
                                 return heapBufferAsPOD<fpreal64>(count);
                         }
    fpreal32            *asF32(int count)
                         { 
                             if (count <= GB_ATTRIBBUF_INITIAL_SIZE_F32)
                                 return myStackBuffer.myF32;
                             else
                                 return heapBufferAsPOD<fpreal32>(count);
                         }

    int64               *asI64(int count)
                         { 
                             if (count <= GB_ATTRIBBUF_INITIAL_SIZE_I64)
                                 return myStackBuffer.myI64;
                             else
                                 return heapBufferAsPOD<int64>(count);
                         }
    int32               *asI32(int count)
                         { 
                             if (count <= GB_ATTRIBBUF_INITIAL_SIZE_I32)
                                 return myStackBuffer.myI32;
                             else
                                 return heapBufferAsPOD<int32>(count);
                         }

    UT_Vector3          *asV3(int count)
                         { 
                             if (count*3 <= GB_ATTRIBBUF_INITIAL_SIZE_F32)
                                 return (UT_Vector3 *)myStackBuffer.myF32;
                             else
                                 return (UT_Vector3 *)
                                        heapBufferAsPOD<fpreal32>(count*3);
                         }
    UT_Vector4          *asV4(int count)
                         { 
                             if (count*4 <= GB_ATTRIBBUF_INITIAL_SIZE_F32)
                                 return (UT_Vector4 *)myStackBuffer.myF32;
                             else
                                 return (UT_Vector4 *)
                                        heapBufferAsPOD<fpreal32>(count*4);
                         }
    UT_Matrix3          *asM3(int count)
                         { 
                             if (count*9 <= GB_ATTRIBBUF_INITIAL_SIZE_F32)
                                 return (UT_Matrix3 *)myStackBuffer.myF32;
                             else
                                 return (UT_Matrix3 *)
                                        heapBufferAsPOD<fpreal32>(count*9);
                         }
    UT_Matrix4          *asM4(int count)
                         { 
                             if (count*16 <= GB_ATTRIBBUF_INITIAL_SIZE_F32)
                                 return (UT_Matrix4 *)myStackBuffer.myF32;
                             else
                                 return (UT_Matrix4 *)
                                        heapBufferAsPOD<fpreal32>(count*16);
                         }

private:
    /// @cond

    /// A private template class used to provide templatizable access methods
    /// to the above asFOO() variants.  Specializations of this class for the
    /// (hard-coded) allowable types follow.
    ///
    /// The non-type FAKE parameter is to ensure the following specializations
    /// are only partial, not full.  Full specializations are not allowed at
    /// class scope.  We use a class since method specializations are also not
    /// allowed at class scope.
    template <typename T, int FAKE> class TemplateAdapter
    {
    };
    /// @endcond

#define GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(TOKEN, T) \
    template <int FAKE> class TemplateAdapter<T, FAKE> \
    { \
        public: \
            static T *getRawBuffer(GB_AttributeBuffer &buffer, int count) \
                                    { return buffer.as##TOKEN(count); } \
    }

    /// @cond
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(F64, fpreal64);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(F32, fpreal32);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(I64, int64);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(I32, int32);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(V3, UT_Vector3);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(V4, UT_Vector4);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(M3, UT_Matrix3);
    GB_ATTRIBBUF_ADAPTER_SPECIALIZATION(M4, UT_Matrix4);
    /// @endcond
#undef GB_ATTRIBBUF_ADAPTER_SPECIALIZATION

public:
    /// A template wrapper around the asFOO() methods, useful in template
    /// functions.
    template <typename T>
        T       *asType(int count)
                    {
                        return TemplateAdapter<T,0>::getRawBuffer(*this, count);
                    }

private:
    /// Copy constructor - not available (copying not permitted)
    GB_AttributeBuffer(const GB_AttributeBuffer &);

    /// Assignment operator - not available (copying not permitted)
    GB_AttributeBuffer  &operator=(const GB_AttributeBuffer &src);

    static void compileTimeAssertions();

    /// Template method for ensuring the heap buffer is large enough to hold
    /// count entries of the POD (Plain Old Data) type T.
    template<typename T>
        T *heapBufferAsPOD(int count)
        {
            const int size = count * sizeof(T);
            if (size > myHeapBufferSize)
            {
                if (myHeapBuffer)
                    delete []myHeapBuffer;
                // Operator new[] returns memory properly aligned for any POD
                // type.
                myHeapBuffer = new char[size];
                myHeapBufferSize = size;
            }

            return (T *)myHeapBuffer;
        }

    char        *myHeapBuffer;
    int          myHeapBufferSize;

    union {
        fpreal64         myF64[GB_ATTRIBBUF_INITIAL_SIZE_F64];
        fpreal32         myF32[GB_ATTRIBBUF_INITIAL_SIZE_F32];
        int64            myI64[GB_ATTRIBBUF_INITIAL_SIZE_I64];
        int32            myI32[GB_ATTRIBBUF_INITIAL_SIZE_I32];
        void            *myPtr[GB_ATTRIBBUF_INITIAL_SIZE_PTR];
    } myStackBuffer;
};

#endif

---