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 <GA/GA_Types.h>
#include <VEX/VEX_PodTypes.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_SharedPtr.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>;
}

class GVEX_MetaList;

template <VEX_Precision PREC> class VEX_Instance;
class VEX_ProcArray;

class GT_UtilOpenSubdiv;
class GU_Detail;
class GU_OceanEvaluator;
class GU_PrimRTree;
class GU_RayIntersect;
class GU_SurfaceDistanceCache;
class GU_TetrahedronAdjacency;
class GU_VexGeoInputs;
class GU_WindingNumber2DApprox;
class GU_WindingNumber3DApprox;
class GEO_DetachedHedgeInterface;
class IMG3D_PCloud;

class TS_MetaExpression;
using TS_MetaExpressionPtr = UT_IntrusivePtr<TS_MetaExpression>;

template <typename T> class UT_Array;


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


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