GDT/GDT_PrimitiveList.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_PrimitiveList contains tokens for primitive attributes.
 *              All these tokens are not sparse.
 *
 */
#ifndef __GDT_PrimitiveList_h__
#define __GDT_PrimitiveList_h__

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

#include <GEO/GEO_Detail.h>
#include "GDT_Transform.h"

class GB_PrimitiveGroup;


class GDT_API GDT_PrimitiveList : public GDT_TokenList
{
public:
    GDT_PrimitiveList() : myTransform(0) {}
    GDT_PrimitiveList(const GDT_PrimitiveList &other);
    virtual ~GDT_PrimitiveList();

    // We have to override applyDeltas because we have an extra delta
    virtual void         applyDeltas(GEO_Detail &gdp, bool inverse=false) const;

    // Merge the primitive deltas from another GDT_PrimitiveList
    void                 mergePrimitiveDeltas(const GDT_PrimitiveList &other,
                                              bool inverse = false);

    // Begin and end a transform change to the primitive specified by index.
    // The delta matrix is computed and stored.
    void                 beginPrimitiveTransformChange(const UT_Matrix3 &mat);
    void                 endPrimitiveTransformChange(const UT_Matrix3 &mat,
                                                     unsigned int index);

    // To be implemented if needed...
#if 0
    bool                 takeTransformSnapshot(const GEO_Detail &beforegdp,
                                               const GEO_Detail &aftergdp,
                                               const GB_PrimitiveGroup *grp=0)
                                               { return false; }
#endif

    // 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);

    virtual unsigned int        getElementCount(const GEO_Detail &gdp) const
                                { return gdp.primitives().entries(); }

    virtual void                initIterate() const { myLastIndex = -1; }
    virtual GB_AttributeElem   *getNextAttributeElement(GEO_Detail &gdp) const
                                { return gdp.primitives()(++myLastIndex); }
    virtual GB_AttributeElem    *getAttributeElement(GEO_Detail &gdp,
                                                  unsigned int index) const
                                 { return gdp.primitives()(index); }


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


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

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

    virtual bool                 hasChange() const;
    virtual bool                 haveAttributesChanged() const
                                 { return GDT_TokenList::hasChange(); }
    bool                         hasTransformChanged() const
                                 {
                                     return (myTransform &&
                                             myTransform->changed() > 0);
                                 }
    
    virtual unsigned int         entries() const;
    
    virtual int                  saveTrans(ostream &os, int binary = 0) const;
    virtual bool                 loadTrans(UT_IStream &is, uint numtotal);

    // Zero the primitive deltas
    virtual void                 zeroDeltas();
    // Destroy the primitive deltas, but not the attribute lists
    virtual void                 clearDeltas();
    // Destroy the primitive 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
                         {
                           beforeelem=beforegdp.primitives()(before_elem_index);
                           afterelem =aftergdp.primitives()(after_elem_index);
                         }
    

private:
    // As with the position token, the transform token for primitives
    // is kept apart from the token list.
    GDT_Transform      *myTransform;

    mutable int         myLastIndex;    // for iterating
};
#endif

---