GVEX_GeoCache.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.
 *
 * NAME:        GVEX_GeoCache.h ( GVEX Library, C++)
 *
 * COMMENTS:    Geometry cache for GVEX functions
 */

#ifndef __GVEX_GeoCache__
#define __GVEX_GeoCache__

#include "GVEX_API.h"
#include <GU/GU_Detail.h>
#include <GEO/GEO_Quadric.h>
#include <GEO/GEO_PointGrid.h>
#include <GA/GA_Handle.h>
#include <TS/TS_Expression.h>
#include <TS/TS_Primitive.h>
#include <VEX/VEX_PodTypes.h>
#include <UT/UT_Array.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_Types.h>
#include <openvdb/tools/PointIndexGrid.h>
#include <hboost/any.hpp>

namespace GEO {
template<uint NAXES> class PointBVHT;
using PointBVH = PointBVHT<3>;
}

template <VEX_Precision PREC> class VEX_Instance;
template <VEX_Precision PREC> class VEX_ArrayType;
class VEX_ProcArray;
class GU_Detail;
class GU_RayIntersect;
class GT_UtilOpenSubdiv;
class GEO_MetaExpression;
class GEO_DetachedHedgeInterface;
class TS_MetaExpression;
class TS_MetaPrimitive;
class IMG3D_PCloud;
class GU_TetrahedronAdjacency;
class GU_PrimRTree;
class GU_VexGeoInputs;
class GU_OceanEvaluator;
class GU_SurfaceDistanceCache;
class GU_WindingNumber3DApprox;
class GU_WindingNumber2DApprox;

template <typename T>
struct GVEX_MetaDensity
{
    static void
    import(T &result, TS_MetaPrimitive *mprim, const UT_Vector3 &P)
    {
        result = mprim->density(P);
    }
};
template <>
struct GVEX_MetaDensity<int>
{
    static void
    import(int &result, TS_MetaPrimitive *mprim, const UT_Vector3 &P)
    {
        result = (int)SYSrint(mprim->density(P));
    }
};
template <typename T>
struct GVEX_MetaTransform
{
    static void
    import(T &result, const GEO_Primitive *gprim)
    {
        result = 0;
    }
};
template <>
struct GVEX_MetaTransform<UT_Matrix4>
{
    static void
    import(UT_Matrix4 &result, const GEO_Primitive *gprim)
    {
        if (gprim->getTypeId() == GA_PRIMMETABALL ||
            gprim->getTypeId() == GA_PRIMMETASQUAD)
        {
            static_cast<const GEO_Quadric *>(gprim)->getTransform4(result);
        }
    }
};


class GVEX_API GVEX_GeoStat
{
public:
    const char          *myFilename;
    int                  myMemory;
};

class GVEX_API GVEX_MetaList
{
public:
     GVEX_MetaList();
    ~GVEX_MetaList();

    enum
    {
        GVEX_META_DENSITY,      // meta:density
        GVEX_META_NUMBER,       // meta:prim
        GVEX_META_TRANSFORM,    // meta:transform
        GVEX_META_ATTRIB,       // other attribute
    };

    // Initialize lists
    void        init(VEX_Instance<VEX_32> &state, VEX_ProcArray &proc,
                        const VEXvec3<VEX_32> *P, int pinc, const char *file);

    // Prepare for import from the given attribute channel (the string
    // instruction offset is specified in channel_name).
    bool        setAttribute(VEX_Instance<VEX_32> &state, VEX_ProcArray &proc,
                             int channel_name);

    int                         entries(int pnum) const;
    template <typename T> void importData(T &result, int pnum, int idx)
    {
        if (!myPInc)
            pnum = 0;
        UT_ASSERT(pnum >= 0 && pnum < myListSize);
        UT_Array<TS_MetaPrimitive *> &list = myLists[pnum];
        const UT_Vector3 &P = myP[pnum];

        UT_ASSERT(idx >= 0 && idx < list.entries());
        TS_MetaPrimitive *mprim = list(idx);
        const GEO_Primitive *gprim = mprim->getGeoPrimPtr();

        switch (myMode)
        {
            case GVEX_META_DENSITY:     // meta:density
                GVEX_MetaDensity<T>::import(result, mprim, P);
                break;

            case GVEX_META_NUMBER:      // meta:prim
                result = GA_Size(gprim->getMapIndex());
                break;

            case GVEX_META_TRANSFORM:   // meta:transform
                GVEX_MetaTransform<T>::import(result, gprim);
                break;

            default:                    // Other attribute
                GA_ROHandleT<T> handle(myAttrib);
                if (handle.isValid())
                {
                    GA_AttributeOwner owner = myAttrib->getOwner();
                    GA_Offset offset;
                    if (owner == GA_ATTRIB_PRIMITIVE)
                        offset = gprim->getMapOffset();
                    else if (owner == GA_ATTRIB_DETAIL)
                        offset = GA_Offset(0);
                    else if (gprim->getVertexCount() >= 1)
                    {
                        GA_Offset vtxoff = gprim->getVertexOffset(0);
                        if (owner == GA_ATTRIB_VERTEX)
                            offset = vtxoff;
                        else
                            offset = gprim->getDetail().vertexPoint(vtxoff);
                    }
                    else
                    {
                        result = 0;
                        break;
                    }
                    result = handle.get(offset);
                }
                else
                    result = 0;
                break;
        }
    }

    // Iteration interface for metastart() / metanext()
    void                advance()       { myCurrent++; }
    bool                atEnd(int proc) { return myCurrent >= entries(proc); }
    int                 getCurrent()    { return myCurrent; }

private:
    void                specializeTemplates();
    void                setListSize(int n);
    void                fillList(const UT_Vector3 &P,
                                const TS_MetaExpressionPtr &expr,
                                UT_Array<TS_MetaPrimitive *>&list);

private:
    const GU_Detail                     *myGdp;
    const UT_Vector3                    *myP;
    int                                  myPInc;
    UT_Array<TS_MetaPrimitive *>        *myLists;
    int                                  myListSize;
    const GA_Attribute                  *myAttrib;
    int                                  myMode;
    int                                  myCurrent;
};

/// An item in the geometry cache, which can be a pointer to anything. The
/// cache will take over ownership of the pointer and delete it at the
/// appropriate time.
class GVEX_API GVEX_GeoCacheItem
{
public:
    GVEX_GeoCacheItem()
    {
    }

    template <typename T>
    GVEX_GeoCacheItem(const T *value) : myItem(UT_SharedPtr<const T>(value))
    {
    }

    /// Access this item's data. The type must match, otherwise an exception
    /// will be thrown.
    template <typename T>
    const T *get() const
    {
        return hboost::any_cast< UT_SharedPtr<const T> >(myItem).get();
    }

private:
    hboost::any myItem;
};

/// Callback to create a new item for the GVEX_GeoCache.
template <VEX_Precision PREC>
using GVEX_ConstructCacheItemT = GVEX_GeoCacheItem (*)(VEX_Instance<PREC> &state, const char *filename);

using GVEX_ConstructCacheItem = GVEX_ConstructCacheItemT<VEX_32>;

using GVEX_PointTreeType = GEO::PointBVH;

class GVEX_API GVEX_GeoCache
{
public:
    // Cache controls
    //  The memory available to the cache
    //  Auto-flush turns on automatic flushing of de-referenced geometry
    //  All methods return the previous value.
    //  Pruning the cache will attempt to free up some memory if possible
    static int64         setCacheMemory(int64 memoryinkb=8192);
    static int64         getCacheMemorySize();
    static int           setAutoFlush(int flush);
    static int           getAutoFlush();
    static void          clearCache(int out_of_date_only=0);
    static void          clearCache(const char* file);
    static void          pruneCache();

    static int64         getMemoryUsage();
    static int64         getPeakUsage();

    static void          setDefaultMetaballGeometry(GU_Detail *gdp);

    // Cache queries
    //  Find out how many entries are in the geometry cache
    //  Find out information about each entry (it's possible that the gdp
    //          returned might be null).
    static int           getCacheEntries();
    static void          getCacheStat(GVEX_GeoStat stat[]);

    // Construct a gvex_internalGeo * that refers to a given GU_Detail.
    // This can be used to pre-populate the vexcache of GU_VexGeoInputs.
    static void          createInternalGeos(GU_VexGeoInputs *geoinputs);

    // Look up a GVEX_MetaList given the handle
    static GVEX_MetaList        *getMetaList(int id);

    // Retrieve a new handle id for metaball iteration.  Use getMetaList()
    // to retrieve the object.
    static int                   startMetaList(VEX_Instance<VEX_32> &state,
                                        VEX_ProcArray &proc,
                                        const UT_Vector3 *P,
                                        int pinc, const char *file);

};

template <VEX_Precision PREC>
class GVEX_API GVEX_GeoCacheT
{
public:
    // Internal helper functions for binding geometry to VEX instructions.
    // The bind function will return the index to access the detail (via the
    // getDetail/getRayTree methods).
    static void          bindDetail(VEX_Instance<PREC> &state);

    // Access methods (once the detail has been bound)
    static const GU_Detail      *getDetail(VEX_Instance<PREC> &state,
                                        const char *file);
    static void                  getPrimBBox(VEX_Instance<PREC> &state,
                                        UT_BoundingBox &box,
                                        const char *file);
    static void                  getPrimBBox(VEX_Instance<PREC> &state,
                                        UT_BoundingBox &box,
                                        const char *file,
                                        const char *group);
    static void                  getPointBBox(VEX_Instance<PREC> &state,
                                        UT_BoundingBox &box,
                                        const char *file);
    static void                  getPointBBox(VEX_Instance<PREC> &state,
                                        UT_BoundingBox &box,
                                        const char *file,
                                        const char *group);
    static GU_RayIntersect      *getRayTree(VEX_Instance<PREC> &state,
                                        const char *file);
    static GU_RayIntersect      *getRayTree(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group);
    static GU_RayIntersect      *getMinTree(VEX_Instance<PREC> &state,
                                        const char *file);
    static GU_RayIntersect      *getMinTree(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group);
    static const openvdb::tools::PointIndexGrid *getPointGrid(VEX_Instance<PREC> &state,
                                        float divsize,
                                        const char *file,
                                        const char *group);
    static GA_IndexArray        *getRingZero(VEX_Instance<PREC> &state,
                                        int ptnum,
                                        const char *file);
    static UT_Array<GA_Size>    *getPrimVertexArray(VEX_Instance<PREC> &state,
                                        const char *file);
    static UT_Array<GA_IndexArray> *getRingZeroArray(VEX_Instance<PREC> &state,
                                        const char *file);
    static GEO_DetachedHedgeInterface *getHedge(VEX_Instance<PREC> &state,
                                        const char *file);

    static const GT_UtilOpenSubdiv      *getOSDEvaluator(VEX_Instance<PREC> &state,
                                            const char *file);

    static TS_MetaExpressionPtr  getTSMetaExpr(VEX_Instance<PREC> &state,
                                        const char *file);
    static IMG3D_PCloud         *getPCloud(VEX_Instance<PREC> &state,
                                        const char *file);

    static void                  expandGroup(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group,
                                        int grouptype,
                                        bool ordered,
                                        exint &alen,
                                        const exint *&adata);

    static GU_PrimRTree  *getPrimTree(VEX_Instance<PREC> &state,
                                        const char *file);
    static GU_PrimRTree  *getPrimTree(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group);

    static GVEX_PointTreeType *getPointTree(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group,
                                        const char *attrib);

    static GVEX_PointTreeType *getRadTree(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group,
                                        const char *attrib,
                                        const char *rad,
                                        float radscale);

    static GU_OceanEvaluator *getOceanEval(VEX_Instance<PREC> &state,
                                    const char *file,
                                    int phase, int freq, int amp, 
                                    float hscale, float time,
                                    int mode, int downsample);

    static GU_TetrahedronAdjacency      *getTetAdj(VEX_Instance<PREC> &state,
                                        const char *file);

    static GU_SurfaceDistanceCache *getSDCache(VEX_Instance<PREC> &state,
                                        const char *file,
                                        const char *group,
                                        const char *p_attrib,
                                        float radius,
                                        const char *dist_metric);

    static GU_WindingNumber3DApprox *getWindingNumber(VEX_Instance<PREC> &state,
                                                      const char *file);
    static GU_WindingNumber3DApprox *getWindingNumber(VEX_Instance<PREC> &state,
                                                      const char *file,
                                                      const char *group);
    static GU_WindingNumber2DApprox *getWindingNumber2D(VEX_Instance<PREC> &state,
                                                        const char *file);
    static GU_WindingNumber2DApprox *getWindingNumber2D(VEX_Instance<PREC> &state,
                                                        const char *file,
                                                        const char *group);
    

    /// Access a custom item in the cache. The type must match, otherwise an
    /// exception will be thrown. The callback will be run to create the item
    /// if an item with that id does not already exist.
    template <typename T>
    static const T *get(const char *id, VEX_Instance<PREC> &state, const char *file,
                        GVEX_ConstructCacheItemT<PREC> callback)
    {
        return getCacheItem(id, state, file, callback).template get<T>();
    }

private:
    /// Helper function to fetch a custom item from the cache, or create it if
    /// necessary.
    static GVEX_GeoCacheItem
    getCacheItem(const char *id, VEX_Instance<PREC> &state, const char *file,
                 GVEX_ConstructCacheItemT<PREC> callback);
};

GVEX_EXTERN_TEMPLATE(GVEX_GeoCacheT<VEX_32>);
GVEX_EXTERN_TEMPLATE(GVEX_GeoCacheT<VEX_64>);

#endif