GEO/GEO_Detail.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 defines the detail class (the container for all points/primitives)
 */

#ifndef __GEO_Detail_h__
#define __GEO_Detail_h__

#include "GEO_API.h"
#include <UT/UT_Color.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector3Array.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_FloatArray.h>
#include <GB/GB_Detail.h>
#include "GEO_Point.h"
#include "GEO_Primitive.h"
#include "GEO_PointList.h"
#include "GEO_PrimList.h"
#include "GEO_AttribDict.h"
#include "GEO_Macros.h"
#include "GEO_AttributeOwner.h"

class UT_Matrix4;
class UT_DMatrix4;
class UT_HashTable;
class UT_String;
class UT_IStream;
class GB_Breakpoint;
class GB_BreakpointGroup;
class GB_Edge;
class GB_EdgeGroup;
class GB_VertexGroup;
class GEO_Vertex;
class GEO_MetaExpression;
class GEO_AttributeHandle;
class GEO_AttributeListHandle;
class GEO_Rolloff;
class GEO_Delta;
class GEO_MirrorParms;
class GEO_PointRedirectArray;
class GEO_PointTree;
class TS_MetaExpression;
class GEO_TempVertexCache;
class GEO_TempPointCache;

//
// these are the names of standard attributes
// These should NOT be used!
//
#define GEO_STD_ATTRIB_NORMAL           "N"
#define GEO_STD_ATTRIB_TEXTURE          "uv"
#define GEO_STD_ATTRIB_VELOCITY         "v"
#define GEO_STD_ATTRIB_MATERIAL         "shop_materialpath"
#define GEO_STD_ATTRIB_OGLSHOP          "ogl_shop"
#define GEO_STD_ATTRIB_DIFFUSE          "Cd"
#define GEO_STD_ATTRIB_ALPHA            "Alpha"
#define GEO_STD_ATTRIB_COM              "com"
#define GEO_STD_ATTRIB_DISTANCE         "dist"
#define GEO_STD_ATTRIB_LOD              "lod"
#define GEO_STD_ATTRIB_REST             "rest"
#define GEO_STD_ATTRIB_MASS             "mass"
#define GEO_STD_ATTRIB_DRAG             "drag"
#define GEO_STD_ATTRIB_TENSION          "tension"
#define GEO_STD_ATTRIB_SPRINGK          "springk"
#define GEO_STD_ATTRIB_LIFE             "life"
#define GEO_STD_ATTRIB_DIST             "dist"
#define GEO_STD_ATTRIB_UP               "up"
#define GEO_STD_ATTRIB_ID               "id"
#define GEO_STD_ATTRIB_PSCALE           "pscale"
#define GEO_STD_ATTRIB_CREASE           "creaseweight"
#define GEO_STD_ATTRIB_AREA             "area"
#define GEO_STD_ATTRIB_PERIMETER        "perimeter"
#define GEO_STD_ATTRIB_WIDTH            "width"
#define GEO_STD_ATTRIB_LAYERMERGE       "layermerge"
#define GEO_STD_ATTRIB_SEGS             "segs"
#define GEO_STD_ATTRIB_DIV              "div"
#define GEO_STD_ATTRIB_LAGE             "lage"
#define GEO_STD_ATTRIB_ARC              "arc"
#define GEO_STD_ATTRIB_GEN              "gen"
#define GEO_STD_ATTRIB_TUBECAPTURE      "tubeCapt"
#define GEO_STD_ATTRIB_PNT_CAPTURE       "pCapt"
#define GEO_STD_ATTRIB_PNT_CAPTURE_ALPHA "pCaptAlpha"
#define GEO_STD_ATTRIB_PNT_CAPTURE_PATH  "pCaptPath"
#define GEO_STD_ATTRIB_PNT_CAPTURE_DATA  "pCaptData"
#define GEO_STD_ATTRIB_CAPTUREFRAME     "pCaptFrame"
#define GEO_STD_ATTRIB_CAPT_SKELROOT    "pCaptSkelRoot"
#define GEO_STD_ATTRIB_WIRE_CAPT        "wireCapt"
#define GEO_STD_ATTRIB_WIRE_CAPT_U      "wireCaptU"
#define GEO_STD_ATTRIB_WIRE_CAPT_V      "wireCaptV"
#define GEO_STD_ATTRIB_WIRE_CAPT_PRIMU  "wireCaptPrimU"
#define GEO_STD_ATTRIB_META_CAPT        "metaCapt"
#define GEO_STD_ATTRIB_META_CAPT_FRAME  "metaCaptFrame"
#define GEO_STD_ATTRIB_META_CAPT_GROUPS "metaCaptGroups"
#define GEO_STD_ATTRIB_META_CAPT_ROOT   "metaCaptRoot"
#define GEO_STD_ATTRIB_META_CAPT_PATHS  "metaCaptPaths"
#define GEO_STD_ATTRIB_META_CAPT_DATA   "metaCaptData"
#define GEO_STD_ATTRIB_META_CAPT_GROUP_MAP "metaCaptGroupMap"
#define GEO_STD_ATTRIB_META_SLIDE       "slideModifier"
#define GEO_STD_ATTRIB_INFLATE_MODIFIER "inflatemodifier"
#define GEO_STD_ATTRIB_INTERNAL_CHANGED_POINTS "internalChangedPoints"
#define GEO_STD_ATTRIB_MUSCLE_REST_ANCHOR "restAnchor"
#define GEO_STD_ATTRIB_MUSCLE_REST_XFORMS "restTransforms"
#define GEO_STD_ATTRIB_MUSCLE_INFLATE_NORM "muscleInflateNormal"
#define GEO_STD_ATTRIB_MUSCLE_POSITION_BIAS "positionbiasvalues"
#define GEO_STD_ATTRIB_RIXLATE          "rixlate"
#define GEO_STD_ATTRIB_MATERIAL_PATH    "shop_materialpath"

/* Update the getStandardAttributes method when adding attribs */
/* These become the indices into the "context" detail attribute to
 * look up when doing a getStandardAttribute */
enum GEO_Standard_Attributes {
    GEO_ATTRIBUTE_NORMAL,
    GEO_ATTRIBUTE_TEXTURE,
    GEO_ATTRIBUTE_VELOCITY,
    GEO_ATTRIBUTE_MATERIAL,
    GEO_ATTRIBUTE_DIFFUSE,
    GEO_ATTRIBUTE_ALPHA,
    GEO_ATTRIBUTE_COM,
    GEO_ATTRIBUTE_DISTANCE,
    GEO_ATTRIBUTE_LOD,
    GEO_ATTRIBUTE_REST,
    GEO_ATTRIBUTE_MASS,
    GEO_ATTRIBUTE_DRAG,
    GEO_ATTRIBUTE_TENSION,
    GEO_ATTRIBUTE_SPRINGK,
    GEO_ATTRIBUTE_LIFE,
    GEO_ATTRIBUTE_DIST,
    GEO_ATTRIBUTE_UP,
    GEO_ATTRIBUTE_ID,
    GEO_ATTRIBUTE_PSCALE,
    GEO_ATTRIBUTE_CREASE,
    GEO_ATTRIBUTE_AREA,
    GEO_ATTRIBUTE_PERIMETER,
    GEO_ATTRIBUTE_WIDTH,
    GEO_ATTRIBUTE_OGLSHOP,
    GEO_ATTRIBUTE_LAYERMERGE,
    GEO_ATTRIBUTE_SEGS,
    GEO_ATTRIBUTE_DIV,
    GEO_ATTRIBUTE_LAGE,
    GEO_ATTRIBUTE_ARC,
    GEO_ATTRIBUTE_GEN,
    GEO_NUM_STANDARD_ATTRIBUTE
};

class GEO_API GEO_Detail : public GB_Detail {
public:
             GEO_Detail();
    virtual ~GEO_Detail();

    //
    //  Clear all the points/primitives out of this detail
    //
    virtual void                         clearAndDestroy();

    //
    //  Stream I/O METHODS
    //
    virtual int          save(const char *, int binary,
                                const UT_Options *options) const;
    virtual int          save(ostream& os, int binary,
                                const UT_Options *options) const;
    virtual int          load(const char *, const UT_Options *options);
    virtual bool         load(UT_IStream &is, const UT_Options *options);

    //
    //  The methods for saving/loading point references should only
    //          be called for saving binary data
    //
    virtual int  saveVertex(ostream &os,const GB_Vertex &vtx,int b) const;
    virtual bool         loadVertex(UT_IStream &is,GB_Vertex &vtx);

    bool         loadPoint(UT_IStream &is, GEO_Point &pt);
    int          saveBinaryPoint(ostream &os, const GEO_Point &pt) const;
    int          saveASCIIPoint (ostream &os, const GEO_Point &pt) const;

    //
    //  Merge the whole detail, or only a group of prims, or only some points.
    //
    void         merge(GEO_Detail &src, const GB_PrimitiveGroup *primGrp = 0,
                             int mergePrimGroup = 1, int insertPrimsAtHead= 0,
                             GEO_PointRedirectArray *dest_to_src_ptarray=0,
                             bool keep_internal_groups = true);
    void         mergePoints(const GEO_Detail &src,
                             const GB_PointGroup *ptGrp = 0,
                             GEO_Point **ptredirect = 0,
                             int merge_groups = 1,
                             bool keep_internal_groups = true);

    void         merge(GEO_Primitive &sprim, int insertPrimAtHead = 0);

    int          copy(const GEO_Detail &src, int method = GB_COPY_ONCE,
                      bool collapse_on_end = true,
                      bool keep_internal_groups = true);

    void         collapseIndexAttributes();

    // Mirrors a portion of the gdp across some plane
    void         mirror(GEO_MirrorParms &parms);

    //
    // Transform/translate all or some of the primitives. The methods will run
    // more efficiently if you happen to know the point closure apriori.
    // If 'quickxform' is true, we don't transform the attributes and don't
    // check for reflection matrix.
    //
    void         transform(const UT_Matrix4 &mat,
                           const GB_PrimitiveGroup *primGrp = 0,
                           const GB_PointGroup *pointClosure = 0,
                           int quickxform = 0,
                           int keep_vector_lengths = 1,
                           int check_pasting = 1,
                           int neg_determinant_flipvector = 1,
                           int update_ptnormals = 0,
                           GEO_Delta *geodelta = 0);

    void         translate(const UT_Vector3 &delta,
                           const GB_PrimitiveGroup *primGrp = 0,
                           const GB_PointGroup *pointClosure = 0,
                           int check_pasting = 1,
                           int update_ptnormals = 0,
                           GEO_Delta *geodelta = 0);

    //
    // Transform/translate all or some of the points.
    //
    void         transformPoints(const UT_Matrix4 &mat,
                                 const GB_PointGroup *pointGroup = 0,
                                 const GB_PrimitiveGroup *primClosure = 0,
                                 int quickxform = 0,
                                 int keep_vector_lengths = 1,
                                 int check_pasting = 1,
                                 int neg_determinant_flipvector = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);
    
    void         translatePoints(const UT_Vector3 &delta,
                                 const GB_PointGroup *pointGroup = 0,
                                 int check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);

    // Transforms edges, calls transformPoints on the point closure of the
    // edges.
    void         transformEdges(const UT_Matrix4 &mat,
                                const GB_EdgeGroup *edgegrp = 0,
                                const GB_PrimitiveGroup *primclosure = 0,
                                int quickxform = 0,
                                int keep_vector_lengths = 1,
                                int check_pasting = 1,
                                int neg_determinant_flipvector = 1,
                                int update_ptnormals = 0,
                                GEO_Delta *geodelta = 0);

    void         translateEdges(const UT_Vector3 &delta,
                                const GB_EdgeGroup *edgegrp = 0,
                                int check_pasting    = 1,
                                int update_ptnormals = 0,
                                GEO_Delta *geodelta = 0);

    // Transforms breakpoints
    void         transformBreakpoints(const UT_Matrix4 &mat,
                                      const GB_BreakpointGroup *grp = 0,
                                      int quickxform = 0,
                                      int update_ptnormals = 0,
                                      GEO_Delta *geodelta = 0);

    void         translateBreakpoints(const UT_Vector3 &delta,
                                      const GB_BreakpointGroup *grp = 0,
                                      int update_ptnormals = 0,
                                      GEO_Delta *geodelta = 0);

    // Convenience function, will call the appropriate transform/translate
    // depending on the type of group
    void         transformGroup(const UT_Matrix4 &mat, const GB_BaseGroup &grp,
                                int quickxform = 0, 
                                int keep_vector_lengths = 1,
                                int check_pasting = 1, 
                                int neg_determinant_flipvector = 1,
                                const GB_PointGroup *ptclosure = 0,
                                const GB_PrimitiveGroup *primclosure = 0,
                                int update_ptnormals = 0,
                                GEO_Delta *geodelta = 0);
    
    void         translateGroup(const UT_Vector3 &delta,
                                const GB_BaseGroup &grp,
                                int check_pasting = 1,
                                const GB_PointGroup *ptclosure = 0,
                                int update_ptnormals = 0,
                                GEO_Delta *geodelta = 0);

    void         visualizeSoftPoints(const GEO_Rolloff &rolloff,
                                const GB_PointGroup *ptgroup,
                                UT_ColorRamp ramp);

    /// The computeNormal methods compute the normals of primitives, points,
    /// edges and breakpoints.  The primitive one is there for completeness.
    /// An edge normal is the average of its point normals.

    /// For internal functions:
    /// If nml_offset > -1, the attribute at that offset will be returned,
    /// else if the geometry has a normal attribute ("N"), nml_offset
    ///         will be set to the offset of that attribute and that attributes
    ///         value will be returned,
    /// else if the geometry has an internal normal attribute ("internalN")
    ///         the value of the internal attribute will be returned and
    ///         nml_offset will be set to its offset,
    /// else the "internalN" attribute is created by a call to normal(1),
    ///         nml_offset is set to it, and the calculated value returned.
    /// If nml_offset is null, the case of nml_offset == -1 is followed
    /// except nml_offset is not written to.
    /// Otherwise:
    /// Recompute the normal. No side-effects happen, but this is much
    /// slower.

    /// WARNING: This could be very slow! Are you sure you need no side-effects?
    /// See computeNormalInternal!
    void         computeNormal(const GEO_Point &point, UT_Vector3 &nml) const;

    /// A faster version of computeNormal which has the side effect of
    /// computing the internal normal if it's not there
    void         computeNormalInternal(const GEO_Point &point, UT_Vector3 &nml);
   
    /// This is the same as prim.computeNormal()
    void         computeNormal(const GEO_Primitive &prim, UT_Vector3 &nml) const;
    /// WARNING: This could be very slow! Are you sure you need no side-effects?
    /// See computeNormalInternal!
    void         computeNormal(const GB_Edge &edge, UT_Vector3 &nml) const;

    /// A faster version of computeNormal which has the side effect of
    /// computing the internal normal if it's not there.
    void         computeNormalInternal(const GB_Edge &edge, UT_Vector3 &nml);

    /// WARNING: This could be very slow! Are you sure you need no side-effects?
    /// See computeNormalInternal!
    void         computeNormal(const GB_Breakpoint &bkpt, UT_Vector3 &nml) const;

    // The normalTranslate* methods translate points, prims, edges or
    // breakpoints along each of their normals.
    void         normalTranslatePoints(float length = 1.0F, 
                                       int check_pasting = 1,
                                       const GB_PointGroup *grp = 0,
                                       int update_ptnormals = 0,
                                       GEO_Delta *geodelta = 0);
    void         normalTranslatePrimitives(float length = 1.0F,
                                       int check_pasting = 1,
                                       const GB_PrimitiveGroup *grp = 0,
                                       int update_ptnormals = 0,
                                       GEO_Delta *geodelta = 0);
    void         normalTranslate(const GB_PointGroup &grp, 
                                 float length = 1.0F, int check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);
    void         normalTranslate(const GB_PrimitiveGroup &grp, 
                                 float length = 1.0F, int check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);
    void         normalTranslate(const GB_EdgeGroup &grp,
                                 float length = 1.0F, int  check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);
    void         normalTranslate(const GB_BreakpointGroup &grp,
                                 float length = 1.0F, int check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);
    void         normalTranslateGroup(const GB_BaseGroup &grp,
                                 float length = 1.0F, int check_pasting = 1,
                                 int update_ptnormals = 0,
                                 GEO_Delta *geodelta = 0);

    // Transform points using soft-selections (proportional xform):
    void         softTransformPoints(const UT_XformOrder &order,
                                     float tx, float ty, float tz,
                                     float rx, float ry, float rz,
                                     float sx, float sy, float sz,
                                     float s_xy, float s_xz, float s_yz,
                                     float px, float py, float pz,
                                     const GEO_Rolloff &rolloff,
                                     const GB_PointGroup *ptgroup = 0,
                                     int quickxform = 0,
                                     int keep_vector_lengths = 1,
                                     int check_pasting = 1,
                                     int neg_determinant_flipvector = 1,
                                     int update_ptnormals = 0,
                                     GEO_Delta *geodelta = 0);
    void         softTransformEdges(const UT_XformOrder &order,
                                     float tx, float ty, float tz,
                                     float rx, float ry, float rz,
                                     float sx, float sy, float sz,
                                     float s_xy, float s_xz, float s_yz,
                                     float px, float py, float pz,
                                     const GEO_Rolloff &rolloff,
                                     const GB_EdgeGroup *edgegrp = 0,
                                     int quickxform = 0,
                                     int keep_vector_lengths = 1,
                                     int check_pasting = 1,
                                     int neg_determinant_flipvector = 1,
                                     int update_ptnormals = 0,
                                     GEO_Delta *geodelta = 0);

    // Translate points using soft-selections (proportional xlate):
    void         softTranslatePoints(const UT_Vector3 &delta,
                                     const GEO_Rolloff &rolloff,
                                     const GB_PointGroup *ptgroup = 0,
                                     int check_pasting = 1,
                                     int update_ptnormals = 0,
                                     GEO_Delta *geodelta = 0);
    void         softTranslateEdges(const UT_Vector3 &delta,
                                     const GEO_Rolloff &rolloff,
                                     const GB_EdgeGroup *edgegrp = 0,
                                     int check_pasting = 1,
                                     int update_ptnormals = 0,
                                     GEO_Delta *geodelta = 0);

    // Translate points along their normals using soft-selections
    void         softNormalTranslatePoints(float distance,
                                           const GEO_Rolloff &rolloff,
                                           const GB_PointGroup *ptgroup = 0,
                                           int along_lead_normal = 1,
                                           int check_pasting = 1,
                                           int update_ptnormals = 0,
                                           GEO_Delta *geodelta = 0);

    //
    // Add and compute normal attributes.  Returns the normal offset.
    // If given a primgroup, only points within the selection are used
    // in the calculation, all others are zeroed.
    virtual int  normal(int internal=0, GB_PrimitiveGroup *primgroup = 0) = 0;
    virtual void normal(UT_Vector3Array &output, bool use_internaln = true) const = 0;

    //
    // Methods for manipulating capture weights (GEO_CaptureWeight.C)
    //
    enum CaptureType
    {
        CAPTURE_BONE = 0,
        CAPTURE_META,
        CAPTURE_WIRE
    };

    /// Get the name of the point attribute which contains (region, weight)
    /// pairs of capture data.
    static const char   *getPointCaptureAttribName(CaptureType type);

    /// Get the name of the detail attribute which contains an index of
    /// region names (like capture regions and metaball groups). Returns NULL
    /// if no such region mapping exists for a type.
    static const char   *getPointCaptureIndexAttribName(CaptureType type);

    /// Get the name of the detail attribute for capture frame. Returns NULL
    /// if a capture type doesn't use capture frame.
    static const char   *getPointCaptureFrameAttribName(CaptureType type);

    /// Get the name of the detail attribute for capture root. Returns NULL
    /// if a capture type doesn't use capture frame.
    static const char   *getPointCaptureRootAttribName(CaptureType type);

    /// Get the name of the detail attribute for capture data (usually,
    /// a linear array of transformation matrices + possibly other data). 
    /// Returns NULL if a capture type doesn't use a capture data attribute.
    static const char   *getPointCaptureDataAttribName(CaptureType type);

    /// Get the size of a point capture data attribute entry, in number of 
    /// floats. This is one entry in the detail attribute mentioned in
    /// getPointCaptureDataAttribName, above. Returns -1 if a capture type
    /// doesn't use a point capture data attribute.
    static int           getPointCaptureDataAttribEntrySize(CaptureType t);

    // Get the cregion root path. Returns true if successful with the value
    // in root_path.
    bool         getCaptureRegionRootPath(UT_String &root_path,
                                          CaptureType t = CAPTURE_BONE) const;
    bool         setCaptureRegionRootPath(const UT_String &root_path,
                                          CaptureType t = CAPTURE_BONE);

    /// Given a string representing a capture region for type t, return that
    /// region's index. -1 is returned if no index exists.
    int          getCaptureRegionIndex(const UT_String &cregion_name,
                                       CaptureType t = CAPTURE_BONE);

    /// Add a new bone capture region. Sets the detail's capture transforms 
    /// for the new region. Returns the index for this new region or -1 for
    /// failure.
    int          addCaptureRegion(const UT_String &cregion_name,
                                  const UT_Matrix4 &parent_xform,
                                  const GEO_Detail *tube_gdp);

    /// Add a non-bone capture capture region of type type to this detail.
    /// Returns the index for this new region, or -1 for failure.
    int          addCaptureRegion(const UT_String &cregion_name,
                                  CaptureType type);
    
    // Delete a capture region (detail and point attributes) data.
    // Return index of deleted attribute, -1 if cannot delete capture region
    int          removeCaptureRegion(const UT_String &cregion_name,
                                     CaptureType t = CAPTURE_BONE);
    
    // constructs a capture region detail attribute data using the given
    // parameters into tube_data which must have
    // GEO_CAPTUREDATA_DETAIL_ATR_ENTRY_SZ number of floats
    static int   constructCaptureRegionDetailData(
                                    const char *cregion_name,
                                    const UT_Matrix4 &parent_xform,
                                    const GEO_Detail *tube_gdp,
                                    float *tube_data );

    // Set the capture weight on a group of points
    void         setCaptureWeight(int cregion_index, float weight,
                                  const GB_PointGroup *ptgroup = 0,
                                  GEO_Delta *geodelta = 0,
                                  int add_weight = 0,
                                  int clamp_negative = 0,
                                  int normalizeweight = 0,
                                  CaptureType t = CAPTURE_BONE);

    // Set the capture weight on a point
    void         setCaptureWeight(int cregion_index, float weight,
                                  GEO_Point *ppt,
                                  GEO_Delta *geodelta = 0,
                                  int add_weight = 0,
                                  int clamp_negative = 0,
                                  int normalizeweight = 0,
                                  CaptureType t = CAPTURE_BONE);

    // Get the capture weight of a point
    float        getCaptureWeight(int cregion_index, const GEO_Point *ppt,
                                  CaptureType t = CAPTURE_BONE) const;

    // Get the average capture weight of a set of points
    int          addAverageCaptureWeight( const GB_PointGroup *ptgroup,
                                          const UT_String &root_path,
                                          UT_HashTable &averages ) const;

    void         getCaptureWeights(const GEO_Point *ppt, UT_IntArray &regions,
                                   UT_FloatArray &weights,
                                   CaptureType t = CAPTURE_BONE) const;
    void         clearCaptureWeights(GEO_Point *ppt,
                                     CaptureType t = CAPTURE_BONE);

    enum VisualizationType
    {
        VISTYPE_SINGLE,
        VISTYPE_MULTIPLE
    };

    // Color points according to their capture weight
    void         colorPointsByCaptureWeight(
                            const UT_PtrArray<const UT_Vector3 *> &colors,
                            const UT_Vector3 &zero_weight_color,
                            CaptureType t = CAPTURE_BONE,
                            VisualizationType vistype = VISTYPE_MULTIPLE,
                            UT_ColorRamp singlevismode = UT_COLORRAMP_FALSE);

    void         normalizeCaptureWeights(const GB_PointGroup *ptgroup = 0,
                                         CaptureType t = CAPTURE_BONE);
    
    // clamp the capture weights to the given low/hi values, if the
    // corresponding flag is true and the capture weight is below/above
    // the corresponding threshold. If low/hi flag is false, the capture
    // weight will be unaffected for respecive clamping.
    void         clampCaptureWeights(const GB_PointGroup *ptgroup = 0,
                            bool clamp_low_flag = true,  
                            float low_threshold = 0.0f, float low_val = 0.0f, 
                            bool clamp_hi_flag  = false, 
                            float hi_threshold  = 1.0f, float hi_val  = 1.0f,
                            CaptureType t = GEO_Detail::CAPTURE_BONE);

    // This specifies a capture index that is exempt from normalization.
    void         normalizeRelativeCaptureWeights(int idx, GEO_Point *pt, 
                                                 GEO_Delta *delta=0);

    //
    // Methods for adding to the point list. The methods that
    // take an attribute data reference "steal" the data pointer and set
    // adata's data pointer to zero.
    //
    GEO_Point           *insertPoint(const GEO_Point *beforeWhich = 0);
    GEO_Point           *appendPoint() { return insertPoint(0); }
    GEO_Point           *insertPoint(const UT_Vector4 &pos, 
                                     GB_AttributeData &adata, 
                                     short stealattrib = 0,
                                     const GEO_Point *beforeWhich = 0);
    GEO_Point           *appendPoint(const UT_Vector4 &pos, 
                                     GB_AttributeData &adata,
                                     short stealattrib = 0)
                         { return insertPoint(pos, adata, stealattrib); }

    // Allocate/free temporaray points.  These points will have invalid point
    // indicies, but can be used to access point attributes for temporary
    // storage.  Please use GEO_TempPointH instead of calling these directly.
    GEO_Point           *allocateTempPoint();
    void                 deleteTempPoint(GEO_Point *pt);

    // Allocate/free temporaray points.  These points will have invalid point
    // indicies, but can be used to access point attributes for temporary
    // storage.  Please use GEO_TempVertexH instead of calling these directly.
    GEO_Vertex          *allocateTempVertex(GEO_Point *pt);
    void                 deleteTempVertex(GEO_Vertex *vtx);

    //
    //  Inserting and appending a new primitive
    //  Insertion works the same way as insertion of points.  However,
    //  The primitive is not allocated since the type is determined
    //  by the allocator.
    //
    GEO_Primitive       *insertPrimitive(unsigned type,
                                const GEO_Primitive *beforeWhich = 0,
                                const GEO_Primitive *src = 0, 
                                GEO_Point **ptredirect = 0);
    GEO_Primitive       *appendPrimitive(unsigned type,
                                const GEO_Primitive *src = 0, 
                                GEO_Point **ptredirect = 0)
                         {
                            return insertPrimitive(type, 0, src, ptredirect);
                         }
    GEO_Primitive       *insertPrimitive(GEO_Primitive *prim, 
                                const GEO_Primitive *beforeWhich = 0,
                                const GEO_Primitive *src = 0,
                                GEO_Point **ptredirect = 0);
    GEO_Primitive       *appendPrimitive(GEO_Primitive *prim,
                                const GEO_Primitive *src = 0,
                                GEO_Point **ptredirect = 0)
                         {
                            return insertPrimitive(prim, 0, src, ptredirect);
                         }

    // Delete a primitive:
    virtual void         deletePrimitive(GB_Primitive &p,int andpoints=0)
                         {
                            deletePrimitive((unsigned)p.getNum(), andpoints);
                         }
    virtual void         deletePrimitive(unsigned int num, int andpoints = 0);

    // Delete a whole group of primitives:
    virtual void         deletePrimitives(const GB_PrimitiveGroup &primGrp,
                                          int andpoints = 0);
    virtual void         deletePrimitives(UT_PtrArray<GEO_Primitive*>& prims_in,
                                          int andpoints = 0);

    // A virtual hook so that GEO_Detail can allocate GEO_Breakpoint for the
    // GB_BreakpointGroup::load() method.
    virtual GB_Breakpoint       *allocBreakpoint() const;

    // Delete a whole group of breakpoints, the group is cleared when done
    virtual void         deleteBreakpoints(GB_BreakpointGroup &bkptgrp);

    //
    //  Find the bounding box (optionally of a group of points)
    // instantiation. Return 0 if the box is empty and 1 otherwise.
    //
    virtual int          getPointBBox(UT_BoundingBox *bbox,
                                      const GB_PointGroup *g = 0) const;
    virtual int          getPointBBox(UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_PointGroup *g=0) const;
    virtual int          getPointBSphere(UT_BoundingSphere *bsphere,
                                      const GB_PointGroup *g = 0,
                                      int updateRequired = 0) const;
    virtual int          getVertexBBox(UT_BoundingBox *bbox,
                                      const GB_VertexGroup *g = 0) const;
    virtual int          getVertexBBox(UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_VertexGroup *g = 0) const;
    virtual int          getEdgeBBox(UT_BoundingBox &bbox,
                                      const GB_EdgeGroup &grp) const;
    virtual int          getEdgeBBox(UT_BoundingBox &bbox, const UT_Matrix4& transform,
                                      const GB_EdgeGroup &grp) const;
    virtual int          getEdgeBSphere(UT_BoundingSphere &bsphere,
                                      const GB_EdgeGroup &grp,
                                      int updateRequired = 0) const;
    virtual int          getBreakpointBBox(UT_BoundingBox &bbox,
                                      const GB_BreakpointGroup &grp) const;
    virtual int          getBreakpointBBox(UT_BoundingBox &bbox, const UT_Matrix4& transform,
                                      const GB_BreakpointGroup &grp) const;
    virtual int          getBreakpointBSphere(UT_BoundingSphere &bsphere,
                                      const GB_BreakpointGroup &grp,
                                      int updateRequired = 0) const;
    virtual int          getGroupBBox(UT_BoundingBox *bbox,
                                      const GB_BaseGroup *grp) const;
    virtual int          getGroupBBox(UT_BoundingBox& bbox, const UT_Matrix4& transform,
                                      const GB_BaseGroup *grp) const;
    virtual int          getGroupBSphere(UT_BoundingSphere *bsphere,
                                      const GB_BaseGroup *grp,
                                      int updateRequired) const;

    // The following method computes either a 2D or 3D bounding box
    // for the specified GB_ATTRIB_FLOAT attribute.
    int                  getPointAttribBBox(const char *name,
                                            UT_BoundingBox *bbox,
                                            const GB_PointGroup *g = 0) const;
    int                  getPointAttribBBox(const char *name,
                                            UT_BoundingBox *bbox,
                                            const GB_PrimitiveGroup &g) const;
    int                  getPointAttribBBox(const char *name,
                                            UT_BoundingBox *bbox,
                                            const GB_EdgeGroup &g) const;
    int                  getPointAttribBBox(const char *name,
                                            UT_BoundingBox *bbox,
                                            const GB_VertexGroup &g) const;

    int                  getPointAttribGroupBBox(const char *name,
                                      UT_BoundingBox *bbox,
                                      const GB_BaseGroup *grp) const;

    int                  getVertexAttribBBox(const char *name,
                                             UT_BoundingBox *bbox,
                                             const GB_PointGroup *g = 0) const;
    int                  getVertexAttribBBox(const char *name,
                                             UT_BoundingBox *bbox,
                                             const GB_PrimitiveGroup &g) const;
    int                  getVertexAttribBBox(const char *name,
                                             UT_BoundingBox *bbox,
                                             const GB_EdgeGroup &g) const;
    int                  getVertexAttribBBox(const char *name,
                                             UT_BoundingBox *bbox,
                                             const GB_VertexGroup &g) const;

    int                  getVertexAttribGroupBBox(const char *name,
                                      UT_BoundingBox *bbox,
                                      const GB_BaseGroup *grp) const;

    // Copy point attribute data from the source point to the dest
    void                 copyPointAttributes(GEO_Point &dest,
                                        const GEO_Point &src) const;
    // Copy vertex attributes from source to destination
    void                 copyVertexAttributes(GEO_Vertex &dest,
                                        const GEO_Vertex &src) const;
    // Copy vertex AND point attributes
    void                 copyPointVertexAttributes(GEO_Vertex &dest,
                                        const GEO_Vertex &src) const;
    // Copy vertex attributes AND change the point reference of the vertex
    void                 copyFullVertex(GEO_Vertex &dest,
                                        const GEO_Vertex &src) const;
    // Copy primitive attributes
    void                 copyPrimitiveAttributes(GEO_Primitive &dest,
                                        const GEO_Primitive &src) const;

    void                 copyPointGroups(GEO_Point &dest,
                                        const GEO_Point &src) const;
    void                 copyPrimitiveGroups(GEO_Primitive &dest,
                                        const GEO_Primitive &src) const;

    // Create a copy of the source vertex. Regardless of the "shallow" parm,
    // this method will copy the vertex attribute data. If not shallow, it
    // will also copy the point attribute data and will assign the source
    // point position to the destination point. If shallow, it will assign the
    // source GEO_Point pointer to the destination.
    void                 copyVertex(GEO_Vertex &dest, const GEO_Vertex &src,
                                    int shallow = 0) const;

    // Blend the vertex attributes, point position and attributes
    void                 blendVertex(GEO_Vertex &dest, const GEO_Vertex &src,
                                     float bias, 
                                     GB_FloatOffsets *ptarray,
                                     GB_FloatOffsets *vtxarray) const;

#if 0
    // This will only blend the point position if it's in the pt_attr_list
    void                 blendVertex(GEO_Vertex &dest, const GEO_Vertex &src, 
                                   fpreal bias, 
                                   GEO_AttributeHandleList *pdata,
                                   GEO_AttributeHandleList *vdata) const;
#endif

    //
    //  The following method will fix all rational curve/patch weights by
    //  flagging the curve/patch appropriately. It is quite expensive since
    //  it traverses the entire primitive list. Only call it as a last resort.
    //
    void                 fixSplineWeights();

    //
    //  Some useful alias functions, they simplify your life a lot
    //  Attribute handling
    //
    // These alias methods return the offset of the (new) attribute, or -1 if
    // they failed for some reason.

    int                  addNormalAttribute(GEO_AttributeOwner who);
    int                  addTextureAttribute(GEO_AttributeOwner who);
    int                  addVelocityAttribute(GEO_AttributeOwner who);
    int                  addAlphaAttribute(GEO_AttributeOwner who);
    int                  addComAttribute(GEO_AttributeOwner who);
    int                  addDiffuseAttribute(GEO_AttributeOwner who);
    int                  addDistanceAttribute(GEO_AttributeOwner who);
    int                  addLODAttribute(GEO_AttributeOwner who);
    int                  addRestAttribute(GEO_AttributeOwner who);
    int                  addTubeCaptureAttribute();

    /// Add the detail's capture frame attribute for capture type t.
    int                  addCaptureFrameAttribute(CaptureType t = CAPTURE_BONE);

    /// Add the bone capture skeleton root detail attribute.
    int                  addCaptureSkelRootAttribute(CaptureType t
                                                                = CAPTURE_BONE);

    /// Add the detail's index attribute used when storing capture weights.
    int                  addPtCapturePathAttribute(CaptureType t =CAPTURE_BONE);

    /// Add the detail's capture data attribute, which usually stores xforms
    /// (and possibly some extra data).
    int                  addPtCaptureAttribute(int num_xforms,
                                               CaptureType t = CAPTURE_BONE);

    /// Add a new custom (index, weight) point attribute.
    int                  addPtIndexPairAttribute(const char *name,
                                                 int size_bytes);

    /// Add the (index, weight) point attribute for capture type t.
    int                  addPointCaptureAttribute(int size,
                                                  CaptureType t = CAPTURE_BONE);

    /// Add the bone capture alpha point attribute.
    int                  addPointCaptureAlphaAttribute(float dflt);

    /// Add a rest anchor transform attribute
    int                  addMetaRestTransformsAttribute(int num_xforms);

    /// Set the internalChangedPoints detail attribute from array of point
    /// numbers. This will return the new offset of the detail attribute
    /// NB: If the attribute already exists, we will grow it as necessary,
    ///     returning a possibly new offset.
    int                  addInternalChangedPointsAttribute(
                                            const UT_IntArray &changed_points);

    int                  findNormalAttribute(GEO_AttributeOwner who) const;
    int                  findTextureAttribute(GEO_AttributeOwner who) const;
    int                  findVelocityAttribute(GEO_AttributeOwner who) const;
    int                  findAlphaAttribute(GEO_AttributeOwner who) const;
    int                  findComAttribute(GEO_AttributeOwner who) const;
    int                  findDiffuseAttribute(GEO_AttributeOwner who) const;
    int                  findDistanceAttribute(GEO_AttributeOwner who) const;
    int                  findLODAttribute(GEO_AttributeOwner who) const;
    int                  findRestAttribute(GEO_AttributeOwner who) const;
    int                  findTubeCaptureAttribute() const;

    /// Find the offset for the detail's capture frame attribute for capture
    /// type t.
    int                  findCaptureFrameAttribute(CaptureType t = CAPTURE_BONE)
                                                                          const;

    /// Find the offset for the bone capture skeleton root detail attribute.
    int                  findCaptureSkelRootAttribute(CaptureType t 
                                                          = CAPTURE_BONE) const;

    /// Find the offset for the detail's index/path attribute, used when
    /// storing capture weights, for capture type t.
    int                  findPtCapturePathAttribute(CaptureType t 
                                                          = CAPTURE_BONE) const;

    /// Find the offset for the detail's capture data attribute.
    int                  findPtCaptureAttribute(CaptureType t = CAPTURE_BONE)
                                                                          const;

    /// Find the offset for the (region, weight) point capture *point*
    /// attribute for capture type t.
    int                  findPointCaptureAttribute(CaptureType t = CAPTURE_BONE)
                                                                          const;
    /// Find the offset for the bone capture alpha point attribute.
    int                  findPointCaptureAlphaAttribute() const;

    /// Find the offset for a custom (index, weight) point attribute.
    int                  findPtIndexPairAttribute(const char *name) const;

    /// Find the offset for a internalChangedPoints detail attribute
    GB_Attribute *       findInternalChangedPointsAttribute() const;
    /// Find the offset for a internalChangedPoints detail attribute and get
    /// its data at the same time. Returns the offset (-1 if not found).
    int                  getInternalChangedPointsAttribute(
                                            UT_IntArray &changed_points) const;

    // Find the offset for the rest anchor transforms attribute
    int                  findMetaRestTransformsAttribute() const;

    void                 destroyNormalAttribute(GEO_AttributeOwner who);
    void                 destroyTextureAttribute(GEO_AttributeOwner who);
    void                 destroyVelocityAttribute(GEO_AttributeOwner who);
    void                 destroyAlphaAttribute(GEO_AttributeOwner who);
    void                 destroyComAttribute(GEO_AttributeOwner who);
    void                 destroyDiffuseAttribute(GEO_AttributeOwner who);
    void                 destroyDistanceAttribute(GEO_AttributeOwner who);
    void                 destroyLODAttribute(GEO_AttributeOwner who);
    void                 destroyRestAttribute(GEO_AttributeOwner who);
    void                 destroyTubeCaptureAttribute();

    /// Destroy the detail's capture frame attribute for capture type t.
    void                 destroyCaptureFrameAttribute(CaptureType t 
                                                                = CAPTURE_BONE);

    /// Destroy the bone capture skeleton root detail attribute.
    void                 destroyCaptureSkelRootAttribute(CaptureType t
                                                                = CAPTURE_BONE);

    /// Destroy the detail's index attribute used when storing capture weights
    /// for capture type t.
    void                 destroyPtCapturePathAttribute(CaptureType t = 
                                                                  CAPTURE_BONE);

    /// Destroy the detail's capture data attribute.
    void                 destroyPtCaptureAttribute(CaptureType t =CAPTURE_BONE);

    /// Destroy the (region, weight) point capture *point* attribute for 
    /// capture type t.
    void                 destroyPointCaptureAttribute(CaptureType t = 
                                                                  CAPTURE_BONE);

    /// Destroy the bone capture alpha point attribute.
    void                 destroyPointCaptureAlphaAttribute();

    /// Destroy a custom (index, weight) point attribute.
    void                 destroyPtIndexPairAttribute(const char *name);

    /// Destroy the internalChangedPoints detail attribute
    void                 destroyInternalChangedPointsAttribute();

    /// Destroy the rest transforms attribute
    void                 destroyMetaRestTransformsAttribute();

    /// Retrieve the restAnchor string attribute from this gdp, if
    /// it exists - return true if successful
    bool                 getMetaRestAnchorPath(UT_String &anchorPath);
    
    // You should never assume that "uv" is textures!
    // Note that Point capture is still special cased.
    // If the supplied layer is <= 0, then the current layer is used.
    // To extract all the layers names, one should do:
    // for (layer = 1; layer <= getNumLayers(); layer++)
    //    layername[layer] = getStdAttributeName(..., layer);
    const char          *getStdAttributeName(GEO_Standard_Attributes name,
                                             int layer = -1) const;
    void                 setStdAttributeName(GEO_Standard_Attributes name,
                                             const char *newname);

    // These handle layers:
    int                  getCurrentLayer() const;
    void                 setCurrentLayer(int layer);
    void                 setNumLayers(int numlayer);
    int                  getNumLayers() const;
    // These get and set the CURRENT layer's merge mode:
    void                 setLayerMerge(int preclear, int mask, int srcblend,
                                        int dstblend);
    void                 getLayerMerge(int &preclear, int &mask, int &srcblend,
                                        int &dstblend);

    void                 addVariableName(const char *attr, const char *varname);
    void                 removeVariableName(const char *varname)
                            { addVariableName(0, varname); }
    // This gets a raw list of the variable maps suitable for caching
    // to see if they changed.
    void                 getVariableNameMap(UT_String &result) const;
    
    // Traverses the variable name mappings currently present:
    void                 traverseVariableNames(int (*function)(const char *attr,
                                    const char *varname, void *data), 
                                    void *data) const;

    // increase the memory size of the attribute
    int                  growPtCaptureAttribute(int num_added_xforms,
                                                CaptureType t = CAPTURE_BONE);
    int                  growPointCaptureAttribute(int added_size,
                                                  CaptureType t = CAPTURE_BONE);
    
    // delete the capture attribute deleting data at offset
    int                  shrinkPtCaptureAttribute(int index, int offset,
                                                  CaptureType t = CAPTURE_BONE);

    int                  addIndexAttribute(const char *n, const char *dv,
                                GEO_AttributeOwner who);
    int                  findIndexAttribute(const char *n,
                                GEO_AttributeOwner who) const;
    void                 destroyIndexAttribute(const char *n,
                                GEO_AttributeOwner who);

    int                  addPointAttrib(const GB_Attribute *src)
                         { return ptAttrib.appendClone(src); }
    int                  addPointAttrib(const char *n, int s,
                                GB_AttribType t, GB_AttribTypeInfo f,
                                const void *dv)
                         { return ptAttrib.append(n, s, t, f, dv); }
    int                  addPointAttrib(const char *n, int s,
                                GB_AttribType t, const void *dv)
                         { return ptAttrib.append(n, s, t, dv); }

    int                  findPointAttrib(const GB_Attribute *src) const
                         { return ptAttrib.getOffset(src); }
    int                  findPointAttrib(const char *n, int s,
                                GB_AttribType t) const
                         { return ptAttrib.getOffset(n, s, t); }

    int                  findPointAttrib(const char *n, GB_AttribType t) const
                         { return ptAttrib.getOffset(n, t); }

    void                 destroyPointAttrib(const char *n, int s,
                                GB_AttribType t)
                         { ptAttrib.destroy(n, s, t); }

    int                  addVertexAttrib(const GB_Attribute *src)
                         { return vtxAttrib.appendClone(src); }
    int                  addVertexAttrib(const char *n, int s,
                                GB_AttribType t, GB_AttribTypeInfo f,
                                const void *dv)
                         { return vtxAttrib.append(n, s, t, f, dv); }
    int                  addVertexAttrib(const char *n, int s,
                                GB_AttribType t, const void *dv)
                         { return vtxAttrib.append(n, s, t, dv); }

    int                  findVertexAttrib(const GB_Attribute *src) const
                         { return vtxAttrib.getOffset(src); }
    int                  findVertexAttrib(const char *n, int s,
                                GB_AttribType t) const
                         { return vtxAttrib.getOffset(n, s, t); }

    void                 destroyVertexAttrib(const char *n, int s,
                                GB_AttribType t)
                         { vtxAttrib.destroy(n, s, t); }

    int                  addPrimAttrib(const GB_Attribute *src)
                         { return primAttrib.appendClone(src); }
    int                  addPrimAttrib(const char *n, int s, GB_AttribType t,
                                       GB_AttribTypeInfo f, const void *dv)
                         { return primAttrib.append(n, s, t, f, dv); }
    int                  addPrimAttrib(const char *n, int s, GB_AttribType t,
                                        const void *dv)
                         { return primAttrib.append(n, s, t, dv); }

    int                  findPrimAttrib(const GB_Attribute *src) const
                         { return primAttrib.getOffset(src); }
    int                  findPrimAttrib(const char *n, int s,
                                GB_AttribType t) const
                         { return primAttrib.getOffset(n, s, t); }

    void                 destroyPrimAttrib(const char *n, int s,
                                        GB_AttribType t)
                         { primAttrib.destroy(n, s, t); }

    // Note: if attrib already exists, will return offset of existing
    // attrib.
    int                  addAttrib(GB_Attribute *src)
                         { return detailAttrib.appendClone(src); }
    int                  addAttrib(const char *n, int s, GB_AttribType t,
                                        const void *dv)
                         { return addAttrib(n, s, t, GB_ATTRIB_INFO_NONE, dv); }
    int                  addAttrib(const char *n, int s, GB_AttribType t,
                                   GB_AttribTypeInfo f, const void *dv)
                         { return detailAttrib.append(n, s, t, f, dv); }

    int                  findAttrib(const GB_Attribute *src) const
                         { return detailAttrib.getOffset(src); }
    int                  findAttrib(const char *n, int s,
                                GB_AttribType t) const
                         { return detailAttrib.getOffset(n, s, t); }
    int                  findAttrib(const char *n, GB_AttribType t) const
                         { return detailAttrib.getOffset(n, t); }

    void                 destroyAttrib(const char *n, int s, GB_AttribType t)
                         { detailAttrib.destroy(n, s, t); }
    void                 destroyAttrib(const char *n, GB_AttribType t)
                         { detailAttrib.destroy(n, t); }

    //
    //  These methods will sort the attributes into a specific order
    //  They are basically used for making two details mergable.
    //  Attributes will be added if they don't already exist.
    //  At the conclusion, the attribute list will be identical
    //  to the table...
    void                 sortAllAttributes(const GEO_Detail &src);

    // Query the internal structures:
    GEO_PointList               &points()
                                 {
                                     return (GEO_PointList&)ptList;
                                 }
    GEO_PrimList                &primitives()
                                 {
                                     return (GEO_PrimList&)primList;
                                 }
    GEO_PointAttribDict         &pointAttribs()         { return ptAttrib;     }
    GEO_PrimAttribDict          &primitiveAttribs()     { return primAttrib;   }
    GEO_VertexAttribDict        &vertexAttribs()        { return vtxAttrib;    }
    GB_AttributeTable           &attribs()              { return detailAttrib; }

    const GEO_PointList         &points() const
                                 {
                                     return (const GEO_PointList&)ptList;
                                 }
    const GEO_PrimList          &primitives() const
                                 {
                                     return (const GEO_PrimList&)primList;
                                 }
    const GEO_PointAttribDict   &pointAttribs() const    { return ptAttrib;  }
    const GEO_PrimAttribDict    &primitiveAttribs() const{ return primAttrib;}
    const GEO_VertexAttribDict  &vertexAttribs() const   { return vtxAttrib; }
    const GB_AttributeTable     &attribs() const         { return detailAttrib;}

    void                         addMetaRef (void)       { myMetaCount++;  }
    void                         delMetaRef (void)       { myMetaCount--;  }
    void                         addPasteRef(void)       { myPasteCount++; }
    void                         addParticleRef(void)    { myParticleCount++; }
    void                         delPasteRef(void)       { myPasteCount--; }
    void                         addQuadricRef(void)     { myQuadricCount++; }
    void                         delQuadricRef(void)     { myQuadricCount--; }
    void                         delParticleRef(void)    { myParticleCount--; }
    void                         addVolumeRef()          { myVolumeCount++; }
    void                         delVolumeRef()          { myVolumeCount--; }

    /// The number of metaball primitives in this gdp.
    int                          metaCount () const   { return myMetaCount;  }
    int                          pasteCount() const   { return myPasteCount; }
    int                          quadricCount() const { return myQuadricCount;}
    int                          particleCount() const 
                                        { return myParticleCount;}
    int                          volumeCount() const
                                        { return myVolumeCount; }

//
//  Warning:  This function is very expensive.  Please cache the value for
//      later use yourself...
    TS_MetaExpression           *getMetaExpression(
                                        GB_PrimitiveGroup *primGroup = 0);
    GEO_MetaExpression          *getGeoMetaExpression() { return metaExpr; }

    // This function will find the GEO_Standard_Attributes enum that
    // matches the provided string s.  1 is returned on succes, 0 on
    // no match.
    unsigned                     getStandardAttributes(const char *s,
                                        GEO_Standard_Attributes &a);


    //
    // These two functions should be used instead of the more
    // destructive clearAndDestroy() when it it likely the
    // geometry it relatively stable between operations
    //

    void                         stashAll();
    void                         destroyStashed();

    void                         mergeCapturePathAndData(
                                        const GEO_Detail &src,
                                        const GB_Attribute *src_path_atr,
                                        const GB_Attribute *my_path_atr,
                                        int src_size, int my_size,
                                        int *&new_indices);


    // Methods for dealing with attribute handles.
    GEO_AttributeHandle  getPointAttribute (const char *attrib_name) const;
    GEO_AttributeHandle  getPrimAttribute  (const char *attrib_name) const;
    GEO_AttributeHandle  getVertexAttribute(const char *attrib_name) const;
    GEO_AttributeHandle  getDetailAttribute(const char *attrib_name) const;
    GEO_AttributeHandle  getAttribute(GEO_AttributeOwner dict,
                                      const char *attrib_name) const;

    /// Change the storage type from one type to another.  For example, cast an
    /// integer attribute into a floating point attribute, or vice versa.
    /// Only some casting methods have been implemented, so it's quite likely
    /// that this method may fail.
    bool        changeAttributeStorage(GEO_AttributeOwner dict,
                                        const char *name,
                                        GB_AttribType new_type);
    bool        changePointAttributeStorage(const char *nm, GB_AttribType t);
    bool        changeVertexAttributeStorage(const char *nm, GB_AttribType t);
    bool        changePrimAttributeStorage(const char *nm, GB_AttribType t);
    bool        changeDetailAttributeStorage(const char *nm, GB_AttribType t);

    GEO_AttributeOwner   getAttributeOwner(const GB_AttributeDict &dict) const;
    const GB_AttributeDict      *getAttributeDict(GEO_AttributeOwner own) const;

    // Functions for building and accessing a point tree.  The second
    // call is used to transform each point before inserting it in
    // to the tree.
    void                         buildPointTree();
    void                         buildPointTree(UT_DMatrix4 &xform);

    // Returns our current point tree.
    GEO_PointTree               *getPointTree() { return myPointTree; }

    void                         destroyPointTree();

    // Merges attributes from 'src' into this detail.  Capture attributes for
    // newly merged points are also updated.  Newly merged points are
    // identified by point numbers beginning from 'num_pts_prev'.
    void         mergeDetailAttributes( const GEO_Detail &src,
                                        int   num_pts_prev );

protected:
    virtual GEO_Primitive       *newPrimitive(unsigned type)  = 0;
    //
    // Create a primitive of a specific type:
    //
    virtual GB_Primitive        *appendNewPrimitive(unsigned type);

    // Primitive type and name:
    virtual unsigned             getPrimitiveType(const char *name) const;
    virtual const char          *getPrimitiveName(unsigned type) const;


    UT_PtrArray<GEO_Point *>             myStashedPoints;
    UT_PtrArray<GEO_Primitive *>         myStashedPrims;

    GEO_TempPointCache                  *myTemporaryPoints;
    GEO_TempVertexCache                 *myTemporaryVertices;

private:
    GEO_Primitive       *replacePrimitive(unsigned type,
                                GEO_Primitive *axeme,
                                const GEO_Primitive *src,
                                GEO_Point **ptredirect);
    GEO_Primitive       *replacePrimitive(GEO_Primitive *prim, 
                                GEO_Primitive *axeme,
                                const GEO_Primitive *src,
                                GEO_Point **ptredirect);

    // helper method for mergeDetailAttributes() -- handles merging
    // capture attributes and may change point capture attributes
    void         mergeCaptureAttributes(const GEO_Detail &src,
                                        int num_pts_before_merge);
    void         mergeWireCaptureAttributes(const GEO_Detail &src,
                                            int num_pts_before_merge);

    void         fastMerge(const GEO_Detail &src, int mergegroups,
                            int collapse = true,
                            bool merge_internal_groups = true);
    void         fastMergePoints(const GEO_Detail &src, int mergegroups,
                            bool merge_internal_groups = true);

    //
    // Private member data:
    //

    GEO_PointAttribDict         ptAttrib;       // list of point attributes
    GEO_PrimAttribDict          primAttrib;     // list of primitive attributes
    GEO_VertexAttribDict        vtxAttrib;      // list of primitive attributes
    GB_AttributeTable           detailAttrib;   // list of detail attribs & data

    GEO_MetaExpression          *metaExpr;      // Meta expression

    // Keep a count of certain primitive types which are trickier and/or
    // expensive to search for.

    int                          myPasteCount;
    int                          myMetaCount;
    int                          myQuadricCount;

    // Keep a count of particle primitives to avoid searches.
    int                          myParticleCount;

    // The count of GEO_PrimVolumes in this detail.
    int                          myVolumeCount;

    // These variables are used to merge several gdps without
    // destroying existing points or primitives until finished

    int                          myExpectedPoints;
    int                          myBasePoint;
    int                          myExpectedPrims;
    int                          myBasePrim;

    // Store a GEO_PointTree data structure, which can be build and
    // accessed via public functions.
    GEO_PointTree               *myPointTree;

public:
    // Some common methods for the standard guys
    int                  addAttribute(const char *, int, GB_AttribType,
                                        const void *dv, GEO_AttributeOwner);
    int                  addAttribute(const char *, int, GB_AttribType,
                                      GB_AttribTypeInfo,
                                      const void *dv, GEO_AttributeOwner);
    int                  growAttribute(const char *name, int added_size,
                                       GB_AttribType type, GEO_AttributeOwner);
    int                  findAttribute(const char *, int, GB_AttribType,
                                        GEO_AttributeOwner) const;
    int                  findAttribute(const char *, GB_AttribType,
                                        GEO_AttributeOwner) const;
    void                 destroyAttribute(const char *, int size,
                                        GB_AttribType, GEO_AttributeOwner);
    void                 destroyAttribute(const char *, 
                                        GB_AttribType, GEO_AttributeOwner);

private:
    GEO_AttributeHandle  getAttributeHandle(const char *name,
                                    const GB_AttributeDict &dict) const;
    int                  saveExtra(ostream &os, int binary) const;
    bool                 loadExtra(UT_IStream &is);
    bool                 loadVersion(UT_IStream &is, int binary);

//
//  Friends
    friend ostream      &operator<<(ostream &os, const GEO_Detail &d)
                        {
                            d.save(os, 0, 0);
                            return os;
                        }
};

#endif

---