GEO/GEO_AttributeHandle.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:        GEO_AttributeHandle.h ( GEO Library, C++)
 *
 * COMMENTS:    A subclass of GB_AttributeHandle which knows about the GEO
 *              classes.
 */

#ifndef __GEO_AttributeHandle__
#define __GEO_AttributeHandle__

#include "GEO_API.h"
#include <GB/GB_AttributeHandle.h>
#include "GEO_AttributeOwner.h"
#include "GEO_Point.h"
#include "GEO_Vertex.h"
#include "GEO_Primitive.h"

class GEO_Detail;
class GEO_Primitive;
class GEO_Vertex;

class GEO_API GEO_AttributeHandle : public GB_AttributeHandle {
public:
    GEO_AttributeHandle();
    GEO_AttributeHandle(const GEO_AttributeHandle &gah);
    GEO_AttributeHandle(const GEO_Detail *gdp, GEO_AttributeOwner owner,
                        GB_Attribute *attrib, const GB_AttributeRef &offset,
                        int size_in_bytes, GB_AttribType type);

    // Special constructor for point position access.  Until we make "P" an
    // attribute, we need this constructor.
    GEO_AttributeHandle(const GEO_Detail *gdp);

    virtual GB_AttributeHandle  *clone() const;
    virtual const char          *getName() const;

    virtual ~GEO_AttributeHandle();

    virtual GEO_AttributeHandle &operator=(const GEO_AttributeHandle &gah);

    virtual void        invalidate();

    virtual bool        isAttributeValid() const;
    virtual bool        isSourceAttributeValid() const;
    void                clearElement()
                            { setRawElement((GB_AttributeElem *)0); }

    /// The myOffset refers to elements which are bound to the handle (i.e
    /// through setElementRaw().  When copying data from other details, the
    /// attribute data doesn't always come from the same location (or even the
    /// same element).  The source offset is used to define the offset from the
    /// source detail (i.e. the detail *not* bound to this handle).
    /// By default, myOffset == mySourceOffset
    void                clearSourceMap()
                            {
                                GB_AttributeRef offset;
                                setSourceMap(GEO_INVALID_DICT, offset);
                            }
    void                setSourceMap(GEO_AttributeOwner dict,
                                const GB_AttributeRef &o);
    void                setSourceMap(const GB_AttributeDict &dict,
                                    GEO_AttributeOwner owner);
    void                setSourceMap(const GEO_AttributeHandle &h);


    virtual void        setElement(GEO_Vertex *v);
    virtual void        setElement(GEO_Point *pt);
    virtual void        setElement(GEO_Primitive *prim);
    virtual void        setElement(GEO_Detail *gdp);

    virtual void        setElement(const GEO_Vertex *v);
    virtual void        setElement(const GEO_Point *pt);
    virtual void        setElement(const GEO_Primitive *prim);
    virtual void        setElement(const GEO_Detail *gdp);

    virtual void        setElement(GEO_Primitive *p, GEO_Vertex *v);
    virtual void        setElement(const GEO_Primitive *p, const GEO_Vertex *v);

    GEO_AttributeOwner  getDictionary() const   { return myDictType; }
    bool                isP() const             { return myIsPointP; }
    GEO_AttributeOwner  getSourceDictionary() const
                                { return mySourceDictType; }

    int                 getFloatCount(bool includePw) const
                        {
                            if (myIsPointP)
                                return includePw ? 4 : 3;
                            return isFloatOrVectorAttribute() ? entries() : 0;
                        }

    // Operations on data
    void        multiply(fpreal w)
                    { GB_AttributeHandle::multiply(w); }
    void        homogenize(fpreal w);
    void        dehomogenize(fpreal w)  { homogenize(1.0/w); }

    // Operations combining other attributes
    void        addScale(const GEO_Primitive *p, const GEO_Vertex *v, fpreal s);
    void        lerp(const GEO_Primitive *p, const GEO_Vertex *v, fpreal w);
    void        lerp(const GEO_Primitive *p0, const GEO_Vertex *v0,
                        const GEO_Primitive *p1, const GEO_Vertex *v1,
                        fpreal w);
    void        multiply(const GEO_Primitive *p, const GEO_Vertex *v);
    void        divide(const GEO_Primitive *p, const GEO_Vertex *v);
    void        copyDataFrom(const GEO_Primitive *p, const GEO_Vertex *v);
    void        copyDataTo(GEO_Primitive *p, GEO_Vertex *v) const;
    bool        equalData(const GEO_Primitive *p,
                            const GEO_Vertex *v, fpreal64 t) const;

    void        addScale(const GEO_Point *elem, fpreal w)
                    { addScaleRaw(elem, w, GEO_POINT_DICT); }
    void        lerp(const GEO_Point *elem, fpreal w)
                    { lerpRaw(elem, w, GEO_POINT_DICT); }
    void        lerp(const GEO_Point *p0, const GEO_Point *p1, fpreal w)
                    { lerpRaw(p0, p1, w, GEO_POINT_DICT); }
    void        multiply(const GEO_Point *elem)
                    { multiplyRaw(elem, GEO_POINT_DICT); }
    void        divide(const GEO_Point *elem)
                    { divideRaw(elem, GEO_POINT_DICT); }
    void        copyDataFrom(const GEO_Point *elem)
                    { copyDataFromRaw(elem, GEO_POINT_DICT); }
    void        copyDataTo(GEO_Point *elem) const
                    { copyDataToRaw(elem, GEO_POINT_DICT); }
    bool        equalData(const GEO_Point *elem, fpreal64 tol) const
                    { return equalDataRaw(elem, tol, GEO_POINT_DICT); }

    void        addScale(const GEO_Vertex *elem, fpreal w)
                    { addScaleRaw(elem, w, GEO_VERTEX_DICT); }
    void        lerp(const GEO_Vertex *elem, fpreal w)
                    { lerpRaw(elem, w, GEO_VERTEX_DICT); }
    void        lerp(const GEO_Vertex *p0, const GEO_Vertex *p1, fpreal w)
                    { lerpRaw(p0, p1, w, GEO_VERTEX_DICT); }
    void        multiply(const GEO_Vertex *elem)
                    { multiplyRaw(elem, GEO_VERTEX_DICT); }
    void        divide(const GEO_Vertex *elem)
                    { divideRaw(elem, GEO_VERTEX_DICT); }
    void        copyDataFrom(const GEO_Vertex *elem)
                    { copyDataFromRaw(elem, GEO_VERTEX_DICT); }
    void        copyDataTo(GEO_Vertex *elem) const
                    { copyDataToRaw(elem, GEO_VERTEX_DICT); }
    bool        equalData(const GEO_Vertex *elem, fpreal64 tol) const
                    { return equalDataRaw(elem, tol, GEO_VERTEX_DICT); }

    void        addScale(const GEO_Primitive *elem, fpreal w)
                    { addScaleRaw(elem, w, GEO_PRIMITIVE_DICT); }
    void        lerp(const GEO_Primitive *elem, fpreal w)
                    { lerpRaw(elem, w, GEO_PRIMITIVE_DICT); }
    void        lerp(const GEO_Primitive *p0, const GEO_Primitive *p1, fpreal w)
                    { lerpRaw(p0, p1, w, GEO_PRIMITIVE_DICT); }
    void        multiply(const GEO_Primitive *elem)
                    { multiplyRaw(elem, GEO_PRIMITIVE_DICT); }
    void        divide(const GEO_Primitive *elem)
                    { divideRaw(elem, GEO_PRIMITIVE_DICT); }
    void        copyDataFrom(const GEO_Primitive *elem)
                    { copyDataFromRaw(elem, GEO_PRIMITIVE_DICT); }
    void        copyDataTo(GEO_Primitive *elem) const
                    { copyDataToRaw(elem, GEO_PRIMITIVE_DICT); }
    bool        equalData(const GEO_Primitive *elem, fpreal64 tol) const
                    { return equalDataRaw(elem, tol, GEO_PRIMITIVE_DICT); }

    // When details can be considered attribute elements, we can move these too
    void        addScale(const GEO_Detail *elem, fpreal w);
    void        lerp(const GEO_Detail *elem, fpreal w);
    void        lerp(const GEO_Detail *gdp0, const GEO_Detail *gdp1, fpreal w);
    void        multiply(const GEO_Detail *elem);
    void        divide(const GEO_Detail *elem);
    void        copyDataFrom(const GEO_Detail *elem);
    void        copyDataTo(GEO_Detail *elem) const;
    bool        equalData(const GEO_Detail *elem, fpreal64 tol) const;

    void        dump(const char *msg="") const;         // For debugging

protected:
    virtual void        setRawElement(GB_AttributeElem *elem);
    virtual void        setRawElement(const GB_AttributeElem *elem);

    //
    // When "P" becomes an attribute on points instead of member data, then we
    // can move all these accessor methods to the base class.  These are
    // "short-cut" methods which avoid having to set the element first.
    // Please see GB_AttributeHandle for details.
    //
    void        addScaleRaw(const GB_AttributeElem *elem, fpreal w,
                        GEO_AttributeOwner owner);
    void        lerpRaw(const GB_AttributeElem *elem, fpreal w,
                        GEO_AttributeOwner owner);
    void        lerpRaw(const GB_AttributeElem *p0,
                        const GB_AttributeElem *p1, fpreal w,
                        GEO_AttributeOwner owner);
    void        multiplyRaw(const GB_AttributeElem *elem,
                        GEO_AttributeOwner owner);
    void        divideRaw(const GB_AttributeElem *elem,
                        GEO_AttributeOwner owner);
    void        copyDataFromRaw(const GB_AttributeElem *elem,
                        GEO_AttributeOwner owner);
    void        copyDataToRaw(GB_AttributeElem *elem,
                        GEO_AttributeOwner owner) const;
    bool        equalDataRaw(const GB_AttributeElem *elem, fpreal64 tol,
                        GEO_AttributeOwner owner) const;

    GEO_Point           *getPoint(GB_AttributeElem *elem)
                             { return static_cast<GEO_Point *>(elem); }
    const GEO_Point     *getPoint(const GB_AttributeElem *elem) const
                             { return static_cast<const GEO_Point *>(elem); }
    UT_Vector4          &getPos(GB_AttributeElem *elem)
                            { return getPoint(elem)->getPos(); }
    const UT_Vector4    &getPos(const GB_AttributeElem *elem) const
                            { return getPoint(elem)->getPos(); }

    bool                myIsPointP;     // Special flag for "P" attrib on points
    GB_AttributeRef     myOffset, mySourceOffset;
    GEO_AttributeOwner  myDictType;
    GEO_AttributeOwner  mySourceDictType;
};

#endif

---