HOM_LopNetwork.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.
 *
 * COMMENTS:
 */

#ifndef __HOM_LopNetwork_h__
#define __HOM_LopNetwork_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_EnumModules.h"
#include "HOM_Errors.h"
#include "HOM_OpNode.h"

class HOM_LopNode;
class HOM_LopExpansionState;
class HOM_LopPostLayer;
class HOM_LopSelectionRule;
class HOM_LopViewportLoadMasks;
class HOM_LopViewportOverrides;

SWIGOUT(%rename(LopNetwork) HOM_LopNetwork;)

class HOM_API HOM_LopNetwork : virtual public HOM_OpNode
{
public:
    HOM_LopNetwork()
    : HOM_NetworkMovableItem(HOM_networkItemType::Node)
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_LopNetwork(const HOM_LopNetwork &pop_node)
    : HOM_OpNode(pop_node),
      HOM_NetworkMovableItem(pop_node)
    { HOM_CONSTRUCT_OBJECT(this) }
    ~HOM_LopNetwork() override
    { HOM_DESTRUCT_OBJECT(this) }

    // Let swig know we're overriding __repr__ for this class so it doesn't
    // provide its own __repr__.
    SWIGOUT(virtual std::string __repr__() = 0;)

    virtual bool isDebugFlagSet() = 0;
    virtual void setDebugFlag(bool on) = 0;

    SWIGOUT(%newobject displayNode;)
    virtual HOM_Node *displayNode() = 0;
    SWIGOUT(%newobject viewerNode;)
    virtual HOM_Node *viewerNode() = 0;

    SWIGOUT(%newobject viewportOverrides;)
    virtual HOM_LopViewportOverrides *viewportOverrides(HOM_LopNode *lop,
            int output_index = 0) = 0;
    SWIGOUT(%kwargs saveNamedViewportOverrides;)
    virtual void saveNamedViewportOverrides(const char *name,
            HOM_LopViewportOverrides *overrides = nullptr) = 0;
    virtual void loadNamedViewportOverrides(const char *name) = 0;
    virtual std::vector<std::string> namedViewportOverrides() = 0;
#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs viewportOverridesLayer;)
    InterpreterObject viewportOverridesLayer(HOM_EnumValue &layer_id =
            HOM_lopViewportOverridesLayer::Custom)
    { return HOMincRef((InterpreterObject)self->
             opaqueViewportOverridesLayer(layer_id)); }
}
#endif
    SWIGOUT(%ignore opaqueViewportOverridesLayer;)
    virtual void *opaqueViewportOverridesLayer(HOM_EnumValue &layer_id =
            HOM_lopViewportOverridesLayer::Custom) = 0;
    virtual HOM_LopViewportOverrides *copyViewportOverrides(
            const char *saved_name = nullptr) = 0;
    virtual void setViewportOverrides(HOM_LopViewportOverrides *overrides) = 0;

    SWIGOUT(%newobject viewportLoadMasks;)
    virtual HOM_LopViewportLoadMasks *viewportLoadMasks() = 0;
    virtual void setViewportLoadMasks(
            HOM_LopViewportLoadMasks *load_masks) = 0;
    virtual void saveNamedViewportLoadMasks(const char *name,
            HOM_LopViewportLoadMasks *load_masks) = 0;
    SWIGOUT(%newobject loadNamedViewportLoadMasks;)
    virtual HOM_LopViewportLoadMasks *loadNamedViewportLoadMasks(
            const char *name) = 0;
    virtual std::vector<std::string> namedViewportLoadMasks() = 0;

    SWIGOUT(%newobject editablePostLayer;)
    virtual HOM_LopPostLayer *editablePostLayer(const char *name,
            HOM_LopNode *lop,
            int output_index = 0) = 0;
    virtual std::vector<std::string> postLayerNames() = 0;
#ifdef SWIG
%extend
{
    InterpreterObject postLayer(const char *name)
    { return HOMincRef((InterpreterObject)self->opaquePostLayer(name)); }
}
#endif
    SWIGOUT(%ignore opaquePostLayer;)
    virtual void *opaquePostLayer(const char *name) = 0;
    virtual void removePostLayer(const char *name) = 0;

    virtual std::vector<std::string> selection() = 0;
    virtual std::string selectionCurrentPrim() = 0;
    virtual std::vector<std::string> selectionWithInstanceIds() = 0;
    SWIGOUT(%kwargs setSelection;)
    virtual void setSelection(
            const std::vector<std::string> &selection,
            const char *currentprim = nullptr) = 0;

    virtual std::map<std::string, HOM_ElemPtr<HOM_LopSelectionRule> >
            selectionRules() = 0;
    virtual void clearSelectionRules() = 0;
    virtual void setSelectionRule(const char *name,
            HOM_LopSelectionRule *rule) = 0;

    virtual HOM_LopExpansionState *expansionState() = 0;
    virtual void setExpansionState(HOM_LopExpansionState *expansion_state) = 0;
    virtual void saveNamedExpansionState(const char *name,
            HOM_LopExpansionState *expansion_state) = 0;
    virtual HOM_LopExpansionState *loadNamedExpansionState(
            const char *name) = 0;
    virtual std::vector<std::string> namedExpansionStates() = 0;

    SWIGOUT(%ignore opaqueSetPrimitiveExpansionLocked;)
    virtual bool opaqueSetPrimitiveExpansionLocked(const char *path,
            void *expanded_subpaths,
            bool preserve_descendant_expansion) = 0;
    virtual bool setPrimitiveExpansionUnlocked(const char *path,
            bool preserve_descendant_expansion = true) = 0;
#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs setPrimitiveExpansionLocked;)
    bool setPrimitiveExpansionLocked(const char *path,
        InterpreterObject expanded_subpaths = nullptr,
        bool preserve_descendant_expansion = true)
    { return self->opaqueSetPrimitiveExpansionLocked(path,
        expanded_subpaths, preserve_descendant_expansion); }
}
#endif

};

#endif