GB/GB_VertexGroup.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:
 *      Ondrej Kos
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Lightweight group definition for vertices (C++)
 *
 * COMMENTS:
 *      Linear indices are used to represent the vertices in each 
 *      primitive.   Both ordered and un-ordered operations are
 *      supported.
 *
 *      TODO: Support ordered operations!
 *
 */

#ifndef __GB_VertexGroup_h__
#define __GB_VertexGroup_h__

#include "GB_API.h"
#include <UT/UT_LinkList.h>
#include <UT/UT_HashTable.h>
#include <UT/UT_RefArray.h>

#include "GB_Detail.h"
#include "GB_VertexData.h"
#include "GB_BaseGroup.h"

typedef UT_RefArray<GB_VertexData> GB_VertexOrderedList;

class GB_VGPrimNode;
class GB_VertexGroup;

class GB_API GB_VertexGroupIterator
{
public:
    GB_VertexGroupIterator(const GB_VertexGroup *grp);
    GB_VertexGroupIterator();

    void        setGroup(const GB_VertexGroup *grp);

    int         head(GB_VertexData &data);
    int         tail(GB_VertexData &data);

    int         next(GB_VertexData &data);
    int         prev(GB_VertexData &data);

private:
    const GB_VertexGroup        *myGroup;
    GB_VGPrimNode       *myCurrentPrimNode;
    unsigned                     myCurrentIndex;
};

class GB_API GB_VertexGroup : public GB_BaseGroup 
{
public:
     GB_VertexGroup(const GB_Detail &gdp, const char *name, int hidden = 1, 
                    unsigned short type = GBVERTEXGROUP);
    ~GB_VertexGroup();

    int          contains(const GB_VertexData &it) const;
    int          contains(const GB_Primitive *prim, int linear_index) const;
    int          containsAny(const GB_Primitive *prim) const;

    // Return the number of vertices from the given primitive contained
    // in this group.
    unsigned     getCount(const GB_Primitive *prim) const;

    // Adds return 1 if successful and 0 otherwise
    int          add(const GB_VertexData &it, int ordered = 0);

    int          add(GB_Primitive *prim, int linear_index, 
                     int ordered = 0);


    // The append options on the toggle methods is used to specify whether
    // or not the edge that is passed in should be used or should a private 
    // copy be used instead.  An append value of 1 will not create a new edge.
    int          toggle(const GB_VertexData &it);

    int          toggle(GB_Primitive *prim, int linear_index);

    int          remove(const GB_VertexData &it);

    int          remove(GB_Primitive *prim, int linear_index);

    // Add all the vertices of the given primitive.  Return 1 if
    // successful, 0 if no change.
    int          addAll(GB_Primitive *prim, int ordered = 0);

    // Remove all the vertices of the given primitive.  Return 1 if
    // successful, 0 if no change.
    int          removeAll(GB_Primitive *prim);

    
    virtual unsigned     entries() const        { return myEntries; }
    virtual int          isEmpty() const        { return (myEntries == 0); }
    virtual void         clearEntries(void);

    virtual int          save(ostream &os, int binary) const;
    virtual bool         load(UT_IStream &is);

    GB_VertexOrderedList        *getOrderedList()
                                 { return myOrderedList; }
    void                         setOrdered(int yesno);

protected:
    UT_LinkList       &list()           { return myPrimList; }
    const UT_LinkList &list() const     { return myPrimList; } 

private:
    GB_VGPrimNode          *findPrimNode(
                                        const GB_Primitive *prim) const;

    int          find(const GB_VertexData &it, 
                      GB_VGPrimNode **node) const;
    int          find(const GB_Primitive *prim, int linear_index,
                      GB_VGPrimNode **node) const;

    GB_VGPrimNode        *addPrimNode(GB_Primitive *prim);
    void                  deletePrimNode(GB_VGPrimNode *node);



private:
    UT_LinkList                  myPrimList;    // list of vertices in the group
    UT_HashTable                 myPrimTable;


    GB_VertexOrderedList        *myOrderedList; 
    int                          myOrderedListDirty;

    unsigned                     myEntries;

    const GB_Detail             &myGdp;

    friend class GB_VertexGroupIterator;
};
#endif

---