GEO/GEO_AttributeHandleList.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_AttributeHandleList.h ( GEO Library, C++)
 *
 * COMMENTS:    Sub-class of GB_AttributeListHandle for GEO elements
 */

#ifndef __GEO_AttributeHandleList__
#define __GEO_AttributeHandleList__

#include "GEO_API.h"

#include <GB/GB_AttributeListHandle.h>
#include "GEO_Detail.h"
#include "GEO_AttributeFilter.h"

class UT_Matrix;
class GEO_AttributeHandle;
class GEO_Delta;

//
// Whether to include "P" in the attribute handle list defined by float
// attributes.  In some cases, it's more useful to skip the "P" attribute since
// it's computed by other means.
//
#define GEO_AHANDLE_LIST_BYPASS_P       0
#define GEO_AHANDLE_LIST_INCLUDE_P      1

class GEO_API GEO_AttributeHandleList : public GB_AttributeListHandle {
public:
             GEO_AttributeHandleList();
    virtual ~GEO_AttributeHandleList();

    GEO_AttributeHandleList     *clone() const;

    void                bindDetail(const GEO_Detail *gdp);
    bool                isBoundDetail(const GEO_Detail *gdp)
                            { return gdp == getDetail(); }

    bool                hasVectorAttributes(GEO_AttributeOwner owner) const;

    //
    // Attribute creation
    //
    // The following methods add attributes to the attribute list based on
    // particular filters.
    //
    void                clearAllAttributes();

    int         appendAttributes(GEO_AttributeOwner,
                                 const GEO_AttributeFilter &filter);
    int         appendAllAttributes(GEO_AttributeOwner owner);
    int         appendFloatAttributes(GEO_AttributeOwner owner,
                                int includeP = GEO_AHANDLE_LIST_INCLUDE_P);
    int         appendAttributesByType(GB_AttribType typ, GEO_AttributeOwner o);
    bool        appendAttributeByName(const char *name, GEO_AttributeOwner o);
    int         appendAttributesByPattern(const char *pattern,
                                        GEO_AttributeOwner o);

    // Remove any attributes from the handle list which don't exist in this
    // "other" detail.
    int         removeAttributes(const GEO_AttributeFilter &filter);
    int         removeMissingAttributes(const GEO_Detail *other);
    bool        removeAttributeByName(const char *name);

    void        clearSourceMap();
    void        appendSourceMap(const GEO_Detail *gdp, GEO_AttributeOwner o);
    void        appendSourceMap(const GEO_AttributeHandleList &hlist);

    GEO_AttributeHandleList     &operator=(const GEO_AttributeHandleList &h);

    GEO_AttributeHandle         *operator[](int i);
    const GEO_AttributeHandle   *operator[](int i) const;
    GEO_AttributeHandle         *operator[](const char *name);
    const GEO_AttributeHandle   *operator[](const char *name) const;

    /// Return the total number of floating point attributes in the list.
    int         getFloatCount(bool includePw=true) const;
    /// Move all the floating point data into a matrix column
    void        floatsToMatrix(UT_Matrix &matrix, int row,
                                bool includePw=true) const;
    /// Extract the floats from the given row of the matrix
    void        matrixToFloats(const UT_Matrix &matrix, int row,
                                bool includePw=true);

    //
    // Preferred methods for working on data.  This allows all handles to be
    // operated on properly.
    //
    void        setElement(GEO_Primitive *prim, GEO_Vertex *v);
    void        setElement(const GEO_Primitive *prim, const GEO_Vertex *v);

    void        add(const GEO_Primitive *p, const GEO_Vertex *v)
                    { addScale(p, v, 1.0); }
    void        addScale(const GEO_Primitive *p, const GEO_Vertex *v, fpreal s);
    void        multiply(const GEO_Primitive *p, const GEO_Vertex *v);
    void        divide(const GEO_Primitive *p, const GEO_Vertex *v);
    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 weight);
    void        copyDataFrom(const GEO_Primitive *p, const GEO_Vertex *v);
    void        copyDataTo(GEO_Primitive *p, GEO_Vertex *v) const;

    // Unary operations on attribute data
    void        setValue(fpreal value); // Usually used to zero data
    void        multiply(fpreal scale); // Multiply all data by value
    void        homogenize(fpreal scale);       // Multiply all but P.w()
    void        dehomogenize(fpreal scale);     // Multiply all but P.w()
    void        transform(const UT_Matrix4 &xform, const UT_Matrix4 &inverse,
                                bool keeplengths=false);
 
    // Alternative operations.  In some cases, it's not possible to get the
    // primitive/vertex, and thus, you need to work on the native element.
    // Only appropriate attribute handles will be operated upon.
    void        setElement(GEO_Point *ppt);
    void        setElement(const GEO_Point *ppt);
    void        setElement(GEO_Vertex *vtx);
    void        setElement(const GEO_Vertex *vtx);
    void        setElement(GEO_Primitive *prim);
    void        setElement(const GEO_Primitive *prim);
    void        setElement(GEO_Detail *gdp);
    void        setElement(const GEO_Detail *gdp);

    // Applied to point attributes only
    void        add(const GEO_Point *ppt)       { addScale(ppt, 1.0); }
    void        addScale(const GEO_Point *ppt, fpreal scale);
    void        lerp(const GEO_Point *ppt, fpreal w);
    void        lerp(const GEO_Point *p0, const GEO_Point *p1, fpreal w);
    void        multiply(const GEO_Point *ppt);
    void        divide(const GEO_Point *ppt);
    void        copyDataFrom(const GEO_Point *ppt);
    void        copyDataTo(GEO_Point *ppt) const;

    // Applied to vertex AND point attributes
    void        add(const GEO_Vertex *ppt)      { addScale(ppt, 1.0); }
    void        addScale(const GEO_Vertex *ppt, fpreal scale);
    void        lerp(const GEO_Vertex *ppt, fpreal w);
    void        lerp(const GEO_Vertex *p0, const GEO_Vertex *p1, fpreal w);
    void        multiply(const GEO_Vertex *ppt);
    void        divide(const GEO_Vertex *ppt);
    void        copyDataFrom(const GEO_Vertex *ppt);
    void        copyDataTo(GEO_Vertex *ppt) const;

    // Applied to primitive AND detail attributes
    void        add(const GEO_Primitive *ppt)   { addScale(ppt, 1.0); }
    void        addScale(const GEO_Primitive *ppt, fpreal scale);
    void        lerp(const GEO_Primitive *ppt, fpreal w);
    void        lerp(const GEO_Primitive *p0, const GEO_Primitive *p1,fpreal w);
    void        multiply(const GEO_Primitive *ppt);
    void        divide(const GEO_Primitive *ppt);
    void        copyDataFrom(const GEO_Primitive *ppt);
    void        copyDataTo(GEO_Primitive *ppt) const;

    // Applied to detail attributes only
    void        add(const GEO_Detail *ppt)      { addScale(ppt, 1.0); }
    void        addScale(const GEO_Detail *ppt, fpreal scale);
    void        lerp(const GEO_Detail *ppt, fpreal w);
    void        lerp(const GEO_Detail *gdp0, const GEO_Detail *gdp1, fpreal w);
    void        multiply(const GEO_Detail *ppt);
    void        divide(const GEO_Detail *ppt);
    void        copyDataFrom(const GEO_Detail *ppt);
    void        copyDataTo(GEO_Detail *ppt) const;

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

    // Add special position attribute "P"
    int         appendPointP();
};

#endif

---