GEO/GEO_SoftTransformCache.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:
 *      Jonathan McGee
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        Geometry library (C++)
 *
 * COMMENTS:    Simple cache for distances between geometry elements
 *              during soft transforms.  These structures are in essense
 *              groups which are not attached to the gdp.  Along with
 *              each soft element of the group, we have a float value which
 *              stores the squared distance to the nearest hard element.
 *
 *              Thus with this cache we are able to store soft squared
 *              distances, and implicitly store connectivity information.
 *              Simply, if an element is not contained in the cache,
 *              it will not be affected by the soft operation.
 */

#ifndef __GU_SoftTransformCache_H__
#define __GU_SoftTransformCache_H__

#include "GEO_API.h"
#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_FloatArray.h>

class GEO_Point;
class GEO_Primitive;

class GEO_API GEO_SoftTransformPointCache
{
public:
    GEO_SoftTransformPointCache();
    ~GEO_SoftTransformPointCache();

    void                 appendHardPt(GEO_Point *pt);
    void                 appendSoftPt(GEO_Point *pt, float dist2);
    
    GEO_Point           *getHardPt(int i) const;

    GEO_Point           *getSoftPt(int i) const;
    float                getSoftDist2(int i) const;
    
    // Number of hard points
    int                  hardEntries() const;
    // Number of soft points
    int                  softEntries() const;

    void                 clearCache();

private:
    UT_PtrArray<GEO_Point*>     myHardPtrArray;
    UT_PtrArray<GEO_Point*>     mySoftPtrArray;
    UT_FloatArray               mySoftDistArray;
};

class GEO_API GEO_SoftTransformVertexCache
{
public:
    GEO_SoftTransformVertexCache();
    ~GEO_SoftTransformVertexCache();

    void                 appendHardVtx(GEO_Primitive *prim, int index);
    void                 appendSoftVtx(GEO_Primitive *prim, int index,
                                       float dist2);
    
    GEO_Primitive       *getHardPrim(int i) const;
    int                  getHardIndex(int i) const;

    GEO_Primitive       *getSoftPrim(int i) const;
    int                  getSoftIndex(int i) const;
    float                getSoftDist2(int i) const;
    
    // Number of hard vertices
    int                  hardEntries() const;
    // Number of soft vertices
    int                  softEntries() const;

    void                 clearCache();

    // Access the soft arrays
    UT_PtrArray<GEO_Primitive*>& softPtrArray() { return mySoftPtrArray; }
    UT_IntArray&                 softIndexArray() { return mySoftIndexArray; }
    UT_FloatArray&               softDistArray() { return mySoftDistArray; }
    
private:
    UT_PtrArray<GEO_Primitive*> myHardPtrArray;
    UT_IntArray                 myHardIndexArray;
    UT_PtrArray<GEO_Primitive*> mySoftPtrArray;
    UT_IntArray                 mySoftIndexArray;
    UT_FloatArray               mySoftDistArray;
};

#endif

---