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

#ifndef __GU_PackedFragment__
#define __GU_PackedFragment__

#include "GU_PackedImpl.h"
#include "GU_DetailHandle.h"
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_WorkBuffer.h>

class GA_PrimitiveFactory;

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

    /// Convenience method to create a packed fragment primitive in the
    /// destination detail.  The packed fragment primitive will embed the
    /// entire source detail but represent just the subset of the source detail
    /// with primitive attribute "ref" having a value of "val".  The source
    /// detail will be copied into the embedded detail.
    ///
    /// The @c dest detail is the detail in which the packed fragment will be
    /// created.  The @c GU_ConstDetailHandle for the @c src will add a
    /// reference to the detail handle (sharing it between multiple fragments).
    /// The @c attrib refers to a primitive string attribute (i.e. "name")
    /// which is used to specify the houdini primitives which compose the
    /// fragment.  The @c val is used to match the attribute to determine
    /// selection of the primitives of the fragment.  For example: @code
    ///   GU_DetailHandleAutoReadLock rlock(src);
    ///   const GU_Detail *srcgdp = rlock.getGdp();
    ///   GA_ROAttributeRef aref = srcgdp->findStringTuple(
    ///                                 GA_ATTRIB_PRIMITIVE, "name");
    ///   exint nstrings = srcgdp->getUniqueValueCount(aref);
    ///   for (exint i = 0; i < nstrings; ++i)
    ///   {
    ///       GU_PrimFragment *prim;
    ///       const char *val = srcgdp->getUniqueStringValue(aref, i);
    ///       // Create a primitive in the @c dest detail
    ///       prim = GU_PackedFragment::createFragment(dest, src, aref, val);
    ///   }
    /// @endcode
    ///
    /// Returns a NULL pointer if the process fails.
    ///
    /// NOTE: The const char* overload is to try to avoid ambiguity if some code
    ///       passes nullptr.
    /// @{
    static GU_PrimPacked *createFragment(
        GU_Detail &dest,
        const GU_ConstDetailHandle &src,
        const GA_Attribute *attrib,
        const UT_StringHolder &val,
        GA_Offset ptoff = GA_INVALID_OFFSET);
    static GU_PrimPacked *createFragment(
        GU_Detail &dest,
        const GU_ConstDetailHandle &src,
        const GA_Attribute *attrib,
        const char *val,
        GA_Offset ptoff = GA_INVALID_OFFSET);
    static GU_PrimPacked *createFragment(
        GU_Detail &dest,
        const GU_ConstDetailHandle &src,
        const GA_Attribute *attrib,
        exint val,
        GA_Offset ptoff = GA_INVALID_OFFSET);
    /// @}

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

    /// Get the type ID for the GU_PackedFragment 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(prim, options, map); }
    bool                supportsJSONLoad() const override { return true; }
    bool                loadFromJSON(
                                GU_PrimPacked *prim,
                                const UT_JSONValueMap &options,
                                const GA_LoadMap &map) override
                            { return loadFrom(prim, options, map); }
    void                update(GU_PrimPacked *prim,
                               const UT_Options &options) override
                            { updateFrom(prim, options); }
    bool                save(UT_Options &options,
                             const GA_SaveMap &map) const override;
    bool                getBounds(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                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(false && "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; }

    /// @}

    /// @{
    /// Member data accessors for intrinsics
    UT_StringHolder attribute() const { return myAttribName; }
    UT_StringHolder intrinsicAttribute(const GU_PrimPacked *prim) const { return attribute(); }
    UT_StringHolder name() const
    {
        if (myIsIntegerAttrib)
        {
            UT_WorkBuffer buf;
            buf.itoa(myAttribIntValue);
            return buf.buffer();
        }

        return myAttribValue;
    }
    bool            isIntValue() const { return myIsIntegerAttrib; }
    exint           intValue() const { return myAttribIntValue; }
    UT_StringHolder intrinsicName(const GU_PrimPacked *prim) const { return name(); }
    void        setAttribute(GU_PrimPacked *prim, const UT_StringHolder &f) { myAttribName = f; }
    void        setName(GU_PrimPacked *prim, const UT_StringHolder &f)
    {
        myIsIntegerAttrib = false;
        myAttribValue = f;
    }
    void        setName(GU_PrimPacked *prim, exint f)
    {
        myIsIntegerAttrib = true;
        myAttribIntValue = f;
    }
    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();
    }
    /// @}

    const GU_ConstDetailHandle  &detailPtr() const {
        loadPackedGeometry();
        return myDetail;
    }
    GA_Range    getPrimitiveRange() const;
    void        setDetails(GU_PrimPacked *prim, const GU_ConstDetailHandle &d, const GA_Attribute *attrib, const UT_StringHolder &name);
    void        setDetails(GU_PrimPacked *prim, const GU_ConstDetailHandle &d, const GA_Attribute *attrib, const char *name);
    void        setDetails(GU_PrimPacked *prim, const GU_ConstDetailHandle &d, const GA_Attribute *attrib, exint id);
protected:
    /// Returns if the filename has changed
    void                 makeEmbeddedname();

    template <typename T>
    bool        loadFrom(GU_PrimPacked *prim, const T &options, const GA_LoadMap &map);

    template <typename T>
    void        updateFrom(GU_PrimPacked *prim, const T &options);

    virtual bool loadPackedGeometry() const;

    UT_StringHolder                     myAttribName;
    UT_StringHolder                     myAttribValue;
    exint                               myAttribIntValue;
    GA_AttributeOwner                   myAttribOwner;
    bool                                myIsIntegerAttrib;
    mutable GU_ConstDetailHandle        myDetail;
    mutable const GA_Attribute         *myCachedAttrib;
    mutable GA_SharedDataHandlePtr      mySharedData;
    mutable UT_Lock                     mySharedDataLock;
    UT_UniquePtr<fpreal64[]>            myBoundingBox;

    static GA_PrimitiveTypeId theTypeId;
};

#endif