GDT/GDT_VertexList.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:
 *      George ElKoura
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GDT Library. (Geo Delta)
 *
 * COMMENTS:    GDT_VertexList contains tokens for vertex attributes.
 *              All these tokens are not sparse.
 *
 */
#ifndef __GDT_VertexList_h__
#define __GDT_VertexList_h__

#include "GDT_API.h"
#include "GDT_TokenList.h"

#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <GEO/GEO_Detail.h>


class GDT_API GDT_VertexList : public GDT_TokenList
{
public:
    GDT_VertexList();
    GDT_VertexList(const GDT_VertexList &other);
    virtual ~GDT_VertexList() {}

    // Merge vertex deltas from another GDT_VertexList
    void                 mergeVertexDeltas(const GDT_VertexList &other,
                                           bool inverse = false);

    // Apply a scaled delta...
    void                 applyScaledDelta(GEO_Detail &gdp, GEO_Primitive &prim,
                                          int vtxidx, float scale) const;

    // End a change to vertex attributes.
    // This method is needed because of the different indexing
    // for vertices.
    void                 endVertexAttributeChange(const GB_AttributeData &data,
                                            unsigned int prim_index,
                                            unsigned int linear_index_in_prim);
    
    // Compute the vertex offsets array.
    // This array must always be in sync with the gdp,
    // otherwise endVertexAttributeChange calls will fail.
    void                 updateVertexOffsets(const GEO_Detail &gdp);
        
    // Can't take const gdps because even looking at an attribute requires
    // write access.
//    virtual bool       takeAttributeSnapshot(const GEO_Detail &beforegdp,
//                                const GEO_Detail &aftergdp,
//                                const UT_String &name,
//                                int size,
//                                GB_AttribType type,
//                                const GB_BaseGroup *grp=0);

    // Methods used to iterate through the vertices
    virtual unsigned int        getElementCount(const GEO_Detail &gdp)   const;
    virtual void                initIterate() const;
    virtual GB_AttributeElem   *getNextAttributeElement(GEO_Detail &gdp) const;
    virtual GB_AttributeElem   *getAttributeElement(GEO_Detail &gdp,
                                                  unsigned int index)    const;



    virtual GB_AttributeDict   &getAttributeDict(GEO_Detail &gdp) const
                                { return gdp.vertexAttribs(); }


    virtual GB_AttributeRef     appendGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int size,
                                                GB_AttribType type,
                                                const void *defvalue) const
                                {
                                    return gdp.vertexAttribs().append(
                                            name, size, type, defvalue);
                                }

    virtual GB_AttributeRef     growGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int oldsize,
                                                GB_AttribType type,
                                                unsigned int addedsize) const
                                { 
                                    return gdp.vertexAttribs().grow(
                                            name, oldsize, type, addedsize); 
                                }

    virtual int                 saveAttribs(ostream &os, int binary = 0) const;
    bool                        loadOffsets(UT_JSONParser &p);
    virtual bool                legacyLoadAttribs(UT_IStream &is, uint size);

    // Destroy the vertex deltas
    virtual void                destroy();

protected:

    virtual void        getAttributeElements(const GEO_Detail &beforegdp,
                                    const GEO_Detail &aftergdp,
                                    unsigned int before_elem_index,
                                    unsigned int after_elem_index,
                                    const GB_AttributeElem *&beforeelem,
                                    const GB_AttributeElem *&afterelem) const;

    // Builds the offset array for a particular gdp.  See below for comments
    // on how the offset array is used.
    void                buildOffsetArray(const GEO_Detail &gdp,
                                         UT_IntArray &array);

    // Given an index and an array of offsets, this method computes the 
    // primitive number and vertex index of the corresponding element.
    // start and end delimit the entries to search in the offsets array
    // Returns true if succesful, false otherwise
    bool                calculatePrimVertex(unsigned int idx, 
                                            const UT_IntArray &offsets,
                                            unsigned int &primidx,
                                            unsigned int &vertexidx,
                                            int start=0,
                                            int end=-1) const;
    
private:

    // myOffsets is used as a way to flatten the vertex indices.  A cell at
    // index i of myOffsets contains the total number of vertices up to, 
    // but not including the primitive i.  For example, myOffsets[0] is always
    // 0.  If primitive 0 had 4 vertices and primitive 1 had 2 then myOffsets[1]
    // would be 4 and myOffsets[2] would be 6, and so on.  That way it is
    // very efficient to index a vertex based on a vertex number and primitive
    // number, it's index would be myOffsets[primnum] + vertexnum.
    // By its nature the offsets array is sorted, so to compute the inverse,
    // that is to find the primitive and vertex index given and index into
    // the vertex array, you just have to do a binary search.  The last
    // entry in the array contains the total number of vertices in the gdp.
    // 
    // Note that this array should be treated as though it were part of the
    // delta.  Since we don't keep around a gdp, this array might not coincide
    // with the gdp that we have to apply the delta to.  This should be treated
    // the same way we treat topology changes in the other lists.
    UT_IntArray                 myOffsets;

    // This is a temporary offset array (like the one above) used to cache this
    // information for another gdp. (This makes taking a snapshot of the 
    // whole gdp faster).  But we do risk it not being in sync with the gdp.
    // 
    // This array is used for the "other" gdp when we are taking a snapshot,
    // in case the two gdp's have the same point and primitive count but
    // a different vertex distribution.
    UT_IntArray                 myTempOffsets;

    // Cache the last primitive and last vertex indices we used for fast
    // iterations.
    mutable unsigned int myNextPrim;
    mutable unsigned int myNextVertex;
};
#endif

---