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

#ifndef __GU_PrimPacked__
#define __GU_PrimPacked__

#include "GU_API.h"
#include "GU_Detail.h"
#include "GU_PackedImpl.h"
#include <GEO/GEO_PrimPacked.h>
#include <GA/GA_PrimitiveDefinition.h>
#include <UT/UT_IntrusivePtr.h>

class GU_PackedFactory;
class GU_PackedImpl;
class GU_PackedContext;
class GEO_ConvertParms;
class UT_MemoryCounter;

class GU_API GU_PrimPacked : public GEO_PrimPacked
{
public:
    // This constructor creates a new GU_PrimPacked but does
    // not append it to the detail.
    // Set add_impl_ref to false if the caller is adding references in bulk.
    GU_PrimPacked(
        const GU_PackedImpl *impl,
        GU_Detail *gdp,
        GA_Offset offset=GA_INVALID_OFFSET,
        bool add_impl_ref=true);
    ~GU_PrimPacked() override;

    const GA_PrimitiveDefinition &getTypeDef() const override;

    /// @{
    /// Find the type information for a given implementation.  May return NULL
    /// or invalid if the type isn't implemented.
    static const GA_PrimitiveDefinition *lookupTypeDef(const UT_StringRef&type);
    static GA_PrimitiveTypeId            lookupTypeId(const UT_StringRef &type);
    /// @}

    /// Build a packed primitive of the specified type name in the given detail.
    /// @{
    static GU_PrimPacked *build(GU_Detail &gdp, const UT_StringRef &type,
                                GA_Offset pt_off = GA_INVALID_OFFSET);
    static GU_PrimPacked *build(GU_Detail &gdp, const UT_StringRef &type,
                                const UT_Options &options,
                                GA_Offset pt_off = GA_INVALID_OFFSET);
    static GU_PrimPacked *build(GU_Detail &gdp, const GA_PrimitiveTypeId &type,
                                GA_Offset pt_off = GA_INVALID_OFFSET);
    static GU_PrimPacked *build(GU_Detail &gdp, const GA_PrimitiveTypeId &type,
                                const UT_Options &options,
                                GA_Offset pt_off = GA_INVALID_OFFSET);
    /// @}

    /// Return true if the primitive definition is implemented using the packed
    /// primitive interface.
    static bool         isPackedPrimitive(const GA_PrimitiveDefinition &pdef);
    static bool         isPackedPrimitive(const GA_PrimitiveTypeId &type);
    static bool         isPackedPrimitive(const GA_Primitive &prim)
                        { return isPackedPrimitive(prim.getTypeId()); }

    /// Convenience method to check whether a detail has any packed primitives
    static bool         hasPackedPrimitives(const GA_Detail &gdp);

    /// Convenience method to return the number of packed primitives
    static GA_Size      countPackedPrimitives(const GA_Detail &gdp);

    /// Returns all the packed primitives in the gdp. Unlike the counting
    /// functions above, this function requires iterating through all
    /// primitives.
    static bool         getPackedPrimitives(const GA_Detail &gdp,
                                UT_Array<const GA_Primitive *> &prims);

    /// Iterate over all packed primitive types and clear any cached geometry
    /// for the type.  The method returns the number of cached items cleared.
    static exint        clearCachedGeometry();

    /// @{
    /// Implementation of methods from GEO level
    void                stashed(bool beingstashed,
                                GA_Offset offset=GA_INVALID_OFFSET) override;
    bool                isDegenerate() const override;
    void                transform(const UT_Matrix4 &xform) override;
    fpreal              calcVolume(const UT_Vector3 &refpt) const override;
    fpreal              calcArea() const override;
    fpreal              calcPerimeter() const override;
    bool                getUntransformedRenderingBounds(
                                UT_BoundingBox &b) const override;
    void                getVelocityRange(UT_Vector3 &v0,
                                         UT_Vector3 &v1) const override;
    virtual void        getWidthRange(fpreal &v0, fpreal &v1) const;
    void                getFullTransform4(UT_Matrix4D &xform) const override;
    bool                saveOptions(UT_Options &options,
                                const GA_SaveMap &map) const override;
    bool                loadOptions(const UT_Options &options,
                                const GA_LoadMap &map) override;
    bool                loadOptionsJSON(UT_JSONParser &p,
                                const GA_LoadMap &map) override;
    bool                loadOptionsJSONMap(UT_JSONValueMap &options,
                                const GA_LoadMap &map) override;
    bool                supportsJSONLoad() const override;
    bool                loadUnknownToken(const char *token,
                                UT_JSONParser &p,
                                const GA_LoadMap &map) override;
    void                copyImplementation(const GEO_PrimPacked &src) override;
    bool                saveSharedLoadData(
                                UT_JSONWriter &w,
                                GA_SaveMap &map,
                                GA_GeometryIndex *geo_index) const override;
    bool                registerSharedLoadData(
                                int dtype,
                                GA_SharedDataHandlePtr item) override;
    void                setAttributeNameMap(
                                const GEO_PackedNameMapPtr &m) override;
    const GEO_PackedNameMapPtr &attributeNameMap() const override;
    void                        setFacesetAttribute(
                                        const UT_StringHolder &s) override;
    const UT_StringHolder      &facesetAttribute() const override;
    /// @}
    /// Implementation of methods from GEO level.  If the boxCache() is valid,
    /// it will be used instead of calling the implementation to perform the
    /// computation.  The implementation should make sure to properly call the
    /// dirty() methods.
    SYS_FORCE_INLINE
    bool getUntransformedBounds(UT_BoundingBox &b) const override final
    { return sharedImplementation()->getBoundsCached(b); }

    /// Set the value for the path attribute.  If the @c value is @c NULL, the
    /// default primitive "path" from the implementation will be used.
    /// This method may add the "path" attribute if it doesn't already exist.
    bool        setPathAttribute(const char *value=NULL,
                            const char *attrib="path");

    /// Report approximate memory usage.
    int64 getMemoryUsage() const override;

    /// Count memory usage using a UT_MemoryCounter in order to count
    /// shared memory correctly.
    /// NOTE: This should always include sizeof(*this).
    void countMemory(UT_MemoryCounter &counter) const override;

    /// Register a procedural factory.
    static void         registerPacked(GA_PrimitiveFactory *prim,
                                    GU_PackedFactory *proc);

    // Conversion Methods
    GEO_Primitive       *convert(GEO_ConvertParms &parms,
                                 GA_PointGroup *usedpts = 0) override;
    GEO_Primitive       *convertNew(GEO_ConvertParms &parms) override;

    void                normal(NormalComp &output) const override {}
    void                normal(NormalCompD &output) const override {}

    /// Return the implementation's packed detail.  This might return a NULL
    /// pointer.
    /// This packed detail should be @b untransformed (i.e. the primitive's
    /// transform shouldn't be included in this).
    GU_ConstDetailHandle        getPackedDetail() const
                            { return sharedImplementation()->getPackedDetail(); }
    GU_ConstDetailHandle        getPackedDetail(GU_PackedContext &context) const
                            { return sharedImplementation()->getPackedDetail(&context); }
    /// Unpack the packed geometry into the given detail.  This method should
    /// ensure that the unpacked geometry has the primitive's transform
    /// applied.
    bool                unpack(GU_Detail &dest) const
                            { return sharedImplementation()->unpack(dest, this); }
    bool                unpackWithContext(GU_Detail &dest, GU_PackedContext &context) const
                            { return sharedImplementation()->unpackWithContext(dest, context, this); }
    bool                unpackUsingPolygons(GU_Detail &dest) const
                            { return sharedImplementation()->unpackUsingPolygons(dest, this); }

    /// Unpack the packed geometry as with the unpack function. In addition,
    /// returns a STY_Styler for each unpacked primitive.
    bool                unpackWithStyler(
        GU_Detail &dest,
        STY_StylerGroup &prim_styler_group,
        const STY_Styler &parent_styler) const
    {
        return sharedImplementation()->unpackWithStyler(
            dest, prim_styler_group, parent_styler, this);
    }

    void                forceLoad() const
                            { return sharedImplementation()->forceLoad(); }

    bool                isLoaded() const
                            { return sharedImplementation()->isLoaded(); }

    /// Returns a const pointer to the GU_PackedImpl.
    /// If you need to modify the GU_PackedImpl, call hardenImplementation()
    /// @{
    SYS_FORCE_INLINE
    const GU_PackedImpl *sharedImplementation() const { return myImplementation.get(); }
    SYS_FORCE_INLINE
    const GU_PackedImpl *sharedImplementation()       { return myImplementation.get(); }
    /// @}
    SYS_DEPRECATED_REPLACE(18.5, sharedImplementation) SYS_FORCE_INLINE
    const GU_PackedImpl *implementation()       { return myImplementation.get(); }


    /// Checks if the GU_PackedImpl is shared, and if so, copies it, to make it
    /// unshared, before returning a non-const pointer to it.
    SYS_FORCE_INLINE
    GU_PackedImpl *hardenImplementation()
    {
        const GU_PackedImpl *impl = myImplementation.get();
        if (impl->isShared())
        {
            impl = impl->copy();
            myImplementation = impl;
        }
        return SYSconst_cast(impl);
    }

    /// Replaces the primitive's GU_PackedImpl with the specified one.
    /// If add_ref is false, the caller is responsible for adding the
    /// reference to the new impl.  If remove_ref is false, the caller
    /// is responsible for removing the reference from the old impl.
    /// NB: This may change the TypeId of this primitive, requiring a
    /// rebuildTracker on the primitive list.
    SYS_FORCE_INLINE
    void setImplementation(const GU_PackedImpl *impl, bool add_ref=true, bool remove_ref=true)
    {
        if (impl == myImplementation.get())
            return;
        if (!remove_ref)
            myImplementation.detach();
        myImplementation.reset(impl, add_ref);
    }

    /// @{
    /// Implementation of dirty methods from GEO
    void                 transformDirty() override;
    void                 attributeDirty() override;
    void                 topologyDirty() override;
    /// @}

    /// multiply xform by transform derived from pivot, local, P and instance
    /// attributes
    void        multiplyByPrimTransform(UT_Matrix4D &xform) const;

    /// Implementation of getFullFullTransform4() which isn't virtual
    /// and doesn't use caching.
    void computeFullTransform4(UT_Matrix4D &xform) const;
protected:
    GA_DECLARE_INTRINSICS(override);
    bool                 doConvert(const GEO_ConvertParms &parms) const;

private:
    UT_IntrusivePtr<const GU_PackedImpl> myImplementation;
    mutable UT_Matrix4D  myCachedFullTransform;
    mutable SYS_AtomicInt64 myCachedFullTransformCount;
};

#endif