GDT/GDT_CaptureWeight.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:
 *      Edward Lam
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GDT_CaptureWeight.h  (Geo Delta Library)
 *
 * COMMENTS:    This contains a full list of vectors that describe the changes
 *              to the gdp's point capture weight attributes.
 *
 */

#ifndef __GDT_CaptureWeight_h__
#define __GDT_CaptureWeight_h__

#include "GDT_API.h"
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_VectorTypes.h>

#include "GDT_Token.h"

class GB_PointGroup;
class GB_CaptureBoneStorage;
class GEO_Detail;
class GDT_TokenList;
class GU_DetailHandle;

typedef int (*GDT_CaptureRegionCB)( void *user_data,
                                    char *cregion,
                                    UT_Matrix4 &parent_xform,
                                    GU_DetailHandle &tube_gdp );


class GDT_API GDT_CaptureWeight : public GDT_Token
{
public:
    GDT_CaptureWeight( unsigned int size );
    virtual ~GDT_CaptureWeight();

    GDT_CaptureWeight( const GDT_CaptureWeight &other );

    void                    getOpPaths( UT_StringList &paths );
    void                    getOpPathsCopy( UT_PtrArray<char *> &paths );
    void                    setOpPaths( const UT_PtrArray<char *> &paths );
    int                     changeOpPaths( const char *old_name,
                                           const char *new_name );
    void                    changeCaptureRegionRoot( const char *old_root,
                                                     const char *new_root );
    void                    refreshCaptureFrameInfo( 
                                        const GEO_Detail &gdp,
                                        GDT_CaptureRegionCB get_region,
                                        void *user_data );

    virtual void            applyDeltas( const GDT_TokenList &token_list,
                                         GEO_Detail &gdp,
                                         bool inverse=false ) const;
    virtual void            applyScaledDelta(GEO_Detail &gdp, GEO_Point &pt,
                                        float scale = 1.0f) const;

    void                    mergeCaptureWeightDeltas(
                                const GDT_CaptureWeight &other,
                                bool inverse = false );

    virtual void            zeroDeltas();
    
    // Begin/end a change to a point capture weight
    void                    initCaptureWeightChange( const GEO_Detail &gdp );
    void                    beginCaptureWeightChange(
                                const GB_AttributeData &data );
    void                    endCaptureWeightChange(
                                const GB_AttributeData &data,
                                unsigned int point_index );

    virtual void            resize( unsigned int size );

    virtual unsigned int    changed() const { return myMaxRow - myMinRow + 1; }

    virtual unsigned int    entries() const { return myNumRows; }

    // I/O Methods
    virtual int             save( ostream &os, int binary = 0 ) const;
    bool                    jsonLoadDelta(UT_JSONParser &p, const char *name);
    virtual bool            legacyLoad( UT_IStream &is );

private:    // not implemented:
//    bool                  takeSnapshot( const GEO_Detail &before_gdp,
//                                        const GEO_Detail &after_gdp,
//                                        const GB_PointGroup *grp=0 );
private:    // methods
    void                    destroy();
    void                    prepareCaptureRegionChange( int path_index );
    bool                    jsonLoadDeltaDefinition(UT_JSONParser &p);
    bool                    jsonLoadProperties(UT_JSONParser &p, int s, int count);
    bool                    jsonLoadObjects(UT_JSONParser &p, int s);
    bool                    jsonLoadObjectSets(UT_JSONParser &p);
    bool                    jsonLoad(UT_JSONParser &p);

private:    // data
    UT_PtrArray<char *>                 myRegionPaths;
    UT_PtrArray<GB_CaptureBoneStorage *>myCaptureTubes;
    UT_PtrArray<UT_FloatArray *>        myValues;
    unsigned int                        myNumRows;
    int                                 myMinRow;
    int                                 myMaxRow;

    // the following data is used for init/begin/end changes
    float *                             mySavedData;
    GB_AttributeRef                     mySavedDataOffset;
    unsigned int                        mySavedDataSize;
    GB_Attribute *                      mySavedPathAttrib;
    GB_AttributeRef                     mySavedTubeOffset;
    const GB_AttributeTable *           mySavedAttribs;
    UT_IntArray                         myMapFromGdp;
};

#endif // __GDT_CaptureWeight_h__

---