LOP_Network.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:        LOP Library (C++)
 *
 * COMMENTS:    LOP manager node for other network types.
 *
 */

#ifndef __LOP_Network_h__
#define __LOP_Network_h__

#include "LOP_API.h"
#include "LOP_Node.h"
#include "LOP_SelectionRule.h"
#include <HUSD/HUSD_ExpansionState.h>
#include <HUSD/HUSD_PostLayers.h>
#include <HUSD/HUSD_FindPrims.h>
#include <HUSD/HUSD_LoadMasks.h>
#include <HUSD/HUSD_Overrides.h>
#include <HUSD/HUSD_Utils.h>
#include <GU/GU_SelectType.h>
#include <UT/UT_StringMap.h>

#define LOP_EXPANSION_DATA_BLOCK_TYPE       "expansion"
#define LOP_OVERRIDES_DATA_BLOCK_TYPE       "overrides"
#define LOP_LOADMASKS_DATA_BLOCK_TYPE       "loadmasks"
#define LOP_POSTLAYERS_DATA_BLOCK_TYPE      "postlayers"
#define LOP_ONLOAD_DATA_BLOCK_PREFIX        "__onload__."

enum LOP_NetworkCustomData
{
    LOP_NETWORK_OVERRIDES,
    LOP_NETWORK_EXPANSION_EFFECT_OVERRIDES,
    LOP_NETWORK_LOADMASKS,
    LOP_NETWORK_POSTLAYERS,
    LOP_NETWORK_SELECTION_RULES,
    LOP_NETWORK_EXPANSION_STATE
};

enum LOP_ExpansionEffect
{
    LOP_EXPANSION_EFFECT_DO_NOTHING,
    LOP_EXPANSION_EFFECT_SET_VISIBILITY,
    LOP_EXPANSION_EFFECT_SET_BOUNDS_DRAWMODE,
    LOP_EXPANSION_EFFECT_COUNT
};

class LOP_API LOP_Network : public LOP_Node
{
public:
    // Standard OP_Network stuff:
    static const char   *theChildTableName;
    static OP_Node      *myConstructor(OP_Network *net, const char *name,
                                OP_Operator *entry);
    static PRM_Template  myTemplateList[];

    bool                         getResolverContextAssetPath(
                                        UT_String &assetpath) override;
    bool                         getResolverContextStrings(
                                        UT_StringMap<UT_StringHolder> &
                                            resolverstrings) override;
    bool                         getVariantSelectionFallbacks(
                                        UT_StringMap<UT_StringArray> &
                                            fallbacks);
    LOP_ExpansionEffect          getExpansionEffect();
    int                          getLargeLayerModifiedPrimCount();

    void                         opChanged(OP_EventType reason,
                                        void *data = 0) override;
    void                         onCreated() override;
    int                          isSubNetwork(bool includemanagementops)
                                        const override;
    OP_Node                     *getDisplayNodePtr() override;
    void                         childFlagChange(OP_Node *nodeptr) override;
    LOP_Node                    *getViewerLop() override;

    HUSD_ConstOverridesPtr       overrides() const
                                 { return myOverrides; }
    void                         setOverrides(const HUSD_Overrides &overrides);
    HUSD_OverridesPtr            editableOverrides();
    void                         resetOverrides();

    HUSD_ConstPostLayersPtr      postLayers() const
                                 { return myPostLayers; }
    HUSD_PostLayersPtr           editablePostLayers();
    void                         resetPostLayers();

    const HUSD_ExpansionState   &expansionState() const
                                 { return myExpansionState; }
    bool                         changeExpansionState(const HUSD_Path &path,
                                        bool pinned, bool expanded);
    bool                         setExpansionState(const HUSD_ExpansionState &
                                        expansion_state);
    bool                         setExpansionLockState(const HUSD_Path &path,
                                        bool locked,
                                        const HUSD_PathSet *
                                            expanded_subpaths = nullptr,
                                        bool use_pinned_subpaths = false,
                                        bool preserve_descendant_expansion = false);
    void                         undoExpansionLockState(
                                        UT_Array<HUSD_Path> &
                                            swap_locked_paths,
                                        UT_Array<HUSD_Path> &
                                            swap_locked_expanded_paths);
    void                         updateOverridesWithExpansionState(
                                        const HUSD_DataHandle &viewerdatahandle,
                                        const HUSD_DataHandle &lopdatahandle);

    const HUSD_LoadMasks        &loadMasks() const
                                 { return myLoadMasks; }
    void                         setLoadMasks(const HUSD_LoadMasks &load_masks);

    bool                         setStateFromDataBlock(
                                        const UT_StringRef &blockname,
                                        const char *blocktype = nullptr);
    bool                         saveExpansionState(
                                        const UT_StringHolder &expansionname,
                                        const HUSD_ExpansionState &expansion);
    bool                         saveOverrides(
                                        const UT_StringHolder &overridesname,
                                        const HUSD_Overrides &overrides);
    bool                         savePostLayers(
                                        const UT_StringHolder &postlayersname,
                                        const HUSD_PostLayers &postlayers);
    bool                         saveLoadMasks(
                                        const UT_StringHolder &load_masks_name,
                                        const HUSD_LoadMasks &load_masks);

    const HUSD_PathSet          &selection() const
                                 { return mySelection; }
    const UT_StringHolder       &selectionCurrentPrim() const
                                 { return mySelectionCurrentPrim; }
    const HUSD_InstanceSelection&selectionWithInstanceIds() const
                                 { return mySelectionWithInstanceIds; }
    // Return true if the selection is actually changed by this call.
    // If not, we do not send the OP_DATA_USERSELECTION_CHANGED event.
    bool                         modifySelection(const HUSD_PathSet &paths,
                                        const HUSD_InstanceSelection &
                                            paths_with_instance_ids,
                                        const UT_StringHolder *currentprim =
                                            nullptr,
                                         GU_SelectionRule rule =
                                             GU_ReplaceSelect);

    const LOP_SelectionRuleMap  &selectionRules() const;
    void                         clearSelectionRules();
    void                         removeSelectionRule(
                                        const UT_StringHolder &name);
    void                         addSelectionRule(
                                        const UT_StringHolder &name,
                                        const LOP_SelectionRule &collection);

    void                         saveSelectionRules(std::ostream &os) const;
    bool                         loadSelectionRules(UT_IStream &is);

    void                         getPinnedPrimitives(
                                        UT_String &pinnedprims) const;
    void                         setPinnedPrimitives(
                                        const UT_StringRef &pinnedprims);

    // Key strings we use during snapshot network serialisation
    static const UT_StringHolder EXTRA_DATA_FORMAT;
    static const UT_StringHolder LAST_PICKED_NODE;
    static const UT_StringHolder PICKED_NODES;

    // When we take a render gallery snapshot, we also save the state of the
    // LOP network. This method encapsulates saving this data.
    void                         saveNetworkForSnapshot(std::ostream &os);

    UT_StringHolder              getRenderGallerySource() const;
    bool                         saveRenderGalleryToDisk();

    static UT_StringHolder       makeValidSelectionRuleName(
                                        const UT_StringHolder &name);

protected:
             LOP_Network(OP_Network *parent, const char *name,
                         OP_Operator *entry);
            ~LOP_Network() override;

    void                 clearAndDestroy() override;

    OP_ERROR             cookMyLop(OP_Context &context) override;

    OP_ERROR             save(std::ostream &os, const OP_SaveFlags &flags,
                                const char *pathPrefix,
                                const UT_StringHolder &name_override =
                                    UT_StringHolder()) override;
    bool                 load(UT_IStream &is, const char *extension,
                                const char *path=0) override;
    void                 loadFinished() override;

private:
    static void          forceRecookAllChildren(LOP_Node *root, bool firstcall);

    HUSD_ExpansionState                  myExpansionState;
    HUSD_LoadMasks                       myLoadMasks;
    HUSD_PostLayersPtr                   myPostLayers;
    HUSD_OverridesPtr                    myOverrides;
    HUSD_PathSet                         mySelection;
    UT_StringHolder                      mySelectionCurrentPrim;
    HUSD_InstanceSelection               mySelectionWithInstanceIds;
    LOP_SelectionRuleMap                 mySelectionRuleMap;
    int                                  mySelectionVersionId;
    int                                  myExpansionStateVersionId;
    LOP_ExpansionEffect                  myLastExpansionStateEffect;
    UT_StringHolder                      myCachedResolverContextAssetPath;
    UT_StringMap<UT_StringHolder>        myCachedResolverContextStrings;
    UT_StringMap<UT_StringArray>         myVariantSelectionFallbacks;
};

#endif