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>

class GB_Attribute;
class GB_FloatOffsets;
class UT_Matrix3;

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

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

    template<typename T>
    T           *castAttribData(int n)
                    { return (T *)((char *)myData+n); }
    template<typename T>
    const T     *castAttribData(int n) const
                    { return (T *)((const char *)myData+n); }


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

    void        *operator[](unsigned n) { return (void *)((char *)myData + n); }
    void        *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...
    //
    void         sumData(const GB_AttributeData &from,
                         const GB_Attribute *table, fpreal scale);
    void         sumData(const GB_AttributeData &from,
                         const GB_Attribute *table);
    void         scaleData(const GB_Attribute *table, fpreal s);

    void         setData(const GB_AttributeData &from, int s)
                 {
                    memcpy(myData, from.getData(), (unsigned)s);
                 }

    //  Set the data for the attributes.  Warning:  Don't use this
    //  unless you really really know what you're doing.  Also,
    //  don't count on this method to stick around.
    void         setData(void *data) { myData = data; }

    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_FloatOffsets
    // should be filled out by using getVectorOffsets().
    void         mulv(fpreal val, const GB_FloatOffsets &foffsets);
    void         mulv(const UT_Matrix3 &val, const GB_FloatOffsets &foffsets,
                        int keepLength = 1);

    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;
                 }

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

private:
    void        *myData;
};

#endif

---