GB/GB_AttributeElem.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 GB_AttributeElem which is
 *      an entity that contains attributes.
 */

#ifndef __GB_AttributeElem_h__
#define __GB_AttributeElem_h__

#include "GB_API.h"
#include <stdlib.h>
#include "GB_AttributeRef.h"
#include "GB_AttributeData.h"

class GB_AttributeMath;
class GB_AttributeDict;

class GB_API GB_AttributeElem
{
public:
    /// copyAttribData() is deprecated in favour of copyAttributeValues()
    void SYS_DEPRECATED  copyAttribData(const GB_AttributeElem *src, int sz);

    // given matching attribute dictionaries, copy the attribute data.
    // this allows for different sized attributes as long as the destination
    // attributes are at least as big as the source attributes.
    // This is a dangerous method to call
    void        copyAttribData(const GB_AttributeElem &src,
                                        const GB_AttributeDict &src_dict,
                                        const GB_AttributeDict &dest_dict);

    /// Operations to work on an individual attribute.  The handle is passed in
    /// and a pointer to the data is returned.
    template<typename T>
    T           *castAttribData(const GB_AttributeRef &n)
                    { return myAttribData.castAttribData<T>(n); }
    template<typename T>
    const T     *castAttribData(const GB_AttributeRef &n) const
                    { return myAttribData.castAttribData<const T>(n); }

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

    /// Operations to work on an individual attribute.  The following templates
    /// can only be instantiated for the types supported by the corresponding
    /// methods on GB_AttributeData.
    ///
    /// @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 myAttribData.getPointer<T>(h, buffer, cnt); }
    template <typename T>
    const T     *getPointer(const GB_AttributeRef &h,
                            GB_AttributeBuffer &buffer, int cnt) const
                    { return myAttribData.getPointer<T>(h, buffer, cnt); }
    template <typename T>
    T           getValue(const GB_AttributeRef &handle, int index = 0) const
                    { return myAttribData.getValue<T>(handle, index); }
    template <typename T>
    void         setValue(const GB_AttributeRef &handle, const T&data, int index = 0)
                    { myAttribData.set<T>(handle, data, index); }
    template <typename T>
    void         get(const GB_AttributeRef &handle, T &data, int index=0) const
                    { myAttribData.get<T>(handle, data, index); }
    template <typename T>
    void         get(const GB_AttributeRef &handle, T *data, int count) const
                    { myAttribData.get<T>(handle, data, count); }
    template <typename T>
    void         set(const GB_AttributeRef &handle, const T *data, int count)
                    { myAttribData.set<T>(handle, data, count); }
    /// @}

    /// @{
    /// The math class provides simple methods to help perform arithmetic
    /// operations on attributes.
    ///
    /// It's possible that a different math operator might be defined for
    /// different handles.  Please ensure that you're calling it with the
    /// correct handle.
    /// @see GB_AttributeMath
    static const GB_AttributeMath       &getMath(const GB_AttributeRef &h);
    /// @}

    /// Compare attribute data
    bool        compareAttributeData(const GB_AttributeElem &cmp,
                        const GB_AttributeDict &table, 
                        fpreal tol = FP32_TOLERANCE) const;

    /// Check to see whether the object has the attribute storage allocated
    bool        hasAllocatedAttributeValues() const;

    /// Ensure that there's enough room to hold the attribute data
    void        allocateAttributeValues(const GB_AttributeDict &dict,
                                bool set_to_default_values=false);

    /// Copy attribute data from the source element to my attributes.  This
    /// assumes that both elements have the same attribute dictionary.
    void        copyAttributeValues(const GB_AttributeElem &src,
                                const GB_AttributeDict &dict);
    /// Multiply numeric values by the scalar value
    void        scaleAttributeValues(fpreal scale,
                                const GB_AttributeDict &dict);
    /// Add the numeric attribute data from the source element, optionally
    /// scaling the source data with the scale given.
    void        addAttributeValues(const GB_AttributeElem &src,
                                const GB_AttributeDict &dict,
                                fpreal scale=1);
    /// Linear interpolate attribute values
    ///  this = (1-bias)*v0 + bias*v1
    void        lerpAttributeValues(const GB_AttributeElem &v0,
                                    const GB_AttributeElem &v1,
                                    fpreal bias,
                                    const GB_AttributeDict &dict);
    /// Barycentric interpolation of attribute values
    ///   this = (1-u-v)*v0 + u*v1 + v*v2
    void        baryAttributeValues(const GB_AttributeElem &v0,
                                    const GB_AttributeElem &v1,
                                    const GB_AttributeElem &v2,
                                    fpreal u, fpreal v,
                                    const GB_AttributeDict &dict);
    /// Bilinear interpolation of attribute values
    ///   this = (1-u)(1-v)*u0v0 + (u)(1-v)*u1v0 + (1-u)(v)*u0v1 + (u)(v)*u1v1
    void        bilinearAttributeValues(const GB_AttributeElem &u0v0,
                                    const GB_AttributeElem &u1v0,
                                    const GB_AttributeElem &u0v1,
                                    const GB_AttributeElem &u1v1,
                                    fpreal u, fpreal v,
                                    const GB_AttributeDict &dict);

#if !defined(HDK_RELAXED_GB)
private:
#endif
    /// getAttribData has been deprecated in favor of the template
    /// castAttribData function which preserves const-ness and eliminates
    /// the need for C-style casting of the return value.
    const void SYS_DEPRECATED   *getAttribData(int n) const 
                    { return myAttribData.castAttribData<const void>(
                                                        GB_AttributeRef(n)); }

    /// Access to the raw attribute data is now deprecated.  Please change your
    /// code to use the accessors (ideally get/set).
    const GB_AttributeData      &getAttrib() const { return myAttribData; }
          GB_AttributeData      &getAttrib()       { return myAttribData; }

protected:
    friend class GB_AttributeTable;
    friend class GB_AttributeDict;

    // The float offset methods need accesses to raw attribute data
    friend class GEO_Point;
    friend class GEO_Vertex;
    friend class GEO_PointAttribDict;
    friend class GEO_VertexAttribDict;
    friend class GEO_PrimAttribDict;
    friend class GEO_Primitive;
    friend class GEO_Face;
    friend class GEO_Curve;
    friend class GEO_Hull;
    friend class GEO_TPSurf;
    friend class GEO_TriMesh;
    friend class GEO_Detail;
    friend class GEO_MetaExpression;
    friend class GEO_PrimPoly;
    friend class GEO_PrimNURBCurve;
    friend class GEO_PrimRBezCurve;
    friend class GEO_PrimNURBSurf;
    friend class GEO_PrimRBezSurf;
    friend class GEO_PrimTriBezier;

    friend class GU_TPSurf;
    friend class GU_Curve;
    friend class GU_PrimNURBCurve;
    friend class GU_PrimNURBSurf;
    friend class GU_PrimPasteDAG;
    friend class GU_PrimTriBezier;

    friend class gq_StitchAccess;

    friend class GDT_Detail;

    friend class GQ_Detail;
    friend class GQ_PolyBevel;

    friend class POP_AttribMap;
    friend class pop_GenVarAccess;
    friend class POP_GenVar;
    friend class POP_Softbody;

    friend class sop_CaptureOverrideAccess;

    friend class POP_Split;

private:

    GB_AttributeData             myAttribData;
    static GB_AttributeMath     *theMath;
};

#endif

---