GU_PackedGeometry.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:        GU_PackedGeometry.h (GU Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_PackedGeometry__
#define __GU_PackedGeometry__

#include "GU_PackedImpl.h"
#include "GU_DetailHandle.h"
#include <GA/GA_Stat.h>

class GA_PrimitiveFactory;

/// Geometry Embedded procedural
class GU_API GU_PackedGeometry : public GU_PackedImpl
{
public:
             GU_PackedGeometry();
             GU_PackedGeometry(const GU_PackedGeometry &src);
            ~GU_PackedGeometry() override;

    /// Convenience method to create a packed primitive in the destination
    /// detail which embeds the source detail.  The source detail will be
    /// copied into the embedded detail.
    /// The source detail's bounding box will be computed.  (But then
    /// cached in the source detail, so multple packs should only
    /// compute the first time)
    ///
    /// Returns a NULL pointer if the process fails.
    /// @{
    static GU_PrimPacked        *packGeometry(GU_Detail &dest,
                                        const GU_ConstDetailHandle &gdh);
    static GU_PrimPacked        *packGeometry(
                                        GU_Detail &dest,
                                        const GU_ConstDetailHandle &gdh,
                                        GA_Offset ptoff);
    /// @}

    /// Provide a bounding box of the gdh, compatible with gdh.getBBox()
    /// useful if you already had to compute it while building gdh.
    /// An invalid bounding box will generate a recompute later,
    /// so can be used if you must delay computation, but this is
    /// not recommended as many readers may demand it simultanesously
    /// leading to performance problems.
    /// @{
    static GU_PrimPacked        *packGeometry(GU_Detail &dest,
                                        const GU_ConstDetailHandle &gdh,
                                        const UT_BoundingBox &bbox);
    static GU_PrimPacked        *packGeometry(GU_Detail &dest,
                                        const GU_ConstDetailHandle &gdh,
                                        const UT_BoundingBox &bbox,
                                        GA_Offset ptoff);
    /// @}

    /// Install the procedural
    static void install(GA_PrimitiveFactory *prim);

    /// Get the type ID for the GU_PackedGeometry primitive type.
    static GA_PrimitiveTypeId typeId()
    {
        return theTypeId;
    }

    /// @{
    /// Implementation of GU_PackedImpl interface
    GU_PackedFactory    *getFactory() const override;
    GU_PackedImpl       *copy() const override;

    bool                isValid() const override;
    void                clearData() override;
    bool                load(GU_PrimPacked *prim, const UT_Options &options,
                             const GA_LoadMap &map) override
                            { return loadFrom(options, map); }
    bool                supportsJSONLoad() const override { return true; }
    bool                loadFromJSON(
                                GU_PrimPacked *prim,
                                const UT_JSONValueMap &options,
                                const GA_LoadMap &map) override
                            { return loadFrom(options, map); }
    void                update(GU_PrimPacked *prim,
                               const UT_Options &options) override;
    bool                save(UT_Options &options,
                             const GA_SaveMap &map) const override;
    bool                getBounds(UT_BoundingBox &box) const override;
    bool                getVisibleBounds(UT_BoundingBox &box) const override;
    bool                getRenderingBounds(UT_BoundingBox &box) const override;
    void                getVelocityRange(UT_Vector3 &min,
                                         UT_Vector3 &max) const override;
    void                getWidthRange(fpreal &min,
                                      fpreal &max) const override;

    bool                unpackWithContext(
                                GU_Detail &destgdp,
                                GU_PackedContext &context,
                                const GU_PrimPacked *prim) const override;
    bool                unpack(GU_Detail &destgdp,
                               const UT_Matrix4D *transform) const override;
    void                forceLoad() const override;
    bool                isLoaded() const override;
    GU_ConstDetailHandle getPackedDetail(
                                GU_PackedContext *context = 0) const override;
    bool                loadSharedData(
                                int dtype,
                                const GA_SharedLoadData *it) override
                        {
                            UT_ASSERT(0 && "Should not be called!");
                            return false;
                        }
    bool                saveSharedData(
                                UT_JSONWriter &w,
                                GA_SaveMap &map,
                                GA_GeometryIndex *geo_index) const override;

    /// Report memory usage (includes all shared memory)
    int64               getMemoryUsage(bool inclusive) const override;

    /// Count memory usage using a UT_MemoryCounter in order to count
    /// shared memory correctly.
    void                countMemory(UT_MemoryCounter &counter,
                                    bool inclusive) const override;

    /// We will be saving the contents in the same file so we don't
    /// have to worry about them changing.  This avoids having
    /// to seek & stat to restore as bbox.
    bool                saveCachedBBox() const override { return true; }

    /// @}

    /// Treat as folder gives hint to UI that this packed geometry primitive
    /// should be treated as a "folder"/"directory".
    /// @{
    bool                treatAsFolder() const      { return myTreatAsFolder; }
    void                setTreatAsFolder(bool b)   { myTreatAsFolder = b; }
    /// @}

    /// @{
    /// Member data accessors for intrinsics
    exint geometryId() const
    {
        loadPackedGeometry();
        GU_DetailHandleAutoReadLock gdl(myDetail);
        const GU_Detail *gdp = gdl.getGdp();
        return gdp ? gdp->getUniqueId() : -1;
    }
    exint intrinsicGeometryId(const GU_PrimPacked *prim) const
    {
        return geometryId();
    }
    bool intrinsicTreatAsFolder(const GU_PrimPacked *prim) const
    {
        return treatAsFolder();
    }
    void intrinsicSetTreatAsFolder(GU_PrimPacked *prim, bool b)
    {
        setTreatAsFolder(b);
    }
    /// @}

    const GU_ConstDetailHandle  &detailPtr() const;

    void        setDetailPtr(const GU_DetailHandle &d);
    void        setDetailPtr(const GU_ConstDetailHandle &d);
    void cloneDetailPtr(const GU_ConstDetailHandle &d,
        bool copy_unique_id, bool bump_count, bool copy_detail);

protected:
    template <typename T>
    bool        loadFrom(const T &options, const GA_LoadMap &map);

    bool loadPackedGeometry(GU_PackedContext *context = 0) const;

    bool statPackedGeometry() const;

    GU_ConstDetailHandle                myDetail;
    mutable UT_BoundingBox              myStatBounds;
    mutable GA_SharedDataHandlePtr      mySharedData;
    mutable UT_Lock                     mySharedDataLock;

    bool                                myTreatAsFolder;

    static GA_PrimitiveTypeId theTypeId;

private:
    GU_PackedGeometry &operator=(const GU_PackedGeometry &copy) = delete;

    template <bool VISIBLE_ONLY>
    bool getBoundsImpl(UT_BoundingBox &box) const;
};

#endif