HOM_SceneViewer.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_SceneViewer_h__
#define __HOM_SceneViewer_h__

#include "HOM_BoundingBox.h"
#include "HOM_EnumModules.h"
#include "HOM_GUDetailHandle.h"
#include "HOM_PathBasedPaneTab.h"
#include "HOM_Vector3.h"
#include "HOM_Vector2.h"
#include "HOM_Matrix3.h"
#include <UT/UT_Array.h>
#include <UT/UT_Map.h>
#include <UT/UT_Tuple.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Functor.h>
#include <vector>

class HOM_ConstructionPlane;
class HOM_ReferencePlane;
class HOM_DopData;
class HOM_FlipbookSettings;
class HOM_GeometryViewport;
class HOM_GeometrySelection;
class HOM_Selection;
class HOM_OpNode;
class HOM_ParmTemplateGroup;
class HOM_ViewportVisualizer;

SWIGOUT(%rename(SceneViewer) HOM_SceneViewer;)

class HOM_API HOM_SceneViewer : virtual public HOM_PathBasedPaneTab
{
public:
    typedef std::vector< std::pair<std::string, std::string> >  Bindings;
    typedef std::vector< std::string >                          HandleParmNames;

    HOM_SceneViewer()
    { HOM_CONSTRUCT_OBJECT(this) }

    // Because the lowermost base classes initialize the virtual bases
    // before any non-virtual bases, the correct thing to do here is
    // explicitly call the constructor for HOM_PaneTab.
    HOM_SceneViewer(const HOM_SceneViewer &pane)
    : HOM_PaneTab(pane), HOM_PathBasedPaneTab(pane)
    { HOM_CONSTRUCT_OBJECT(this) }

    ~HOM_SceneViewer() 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;)

    // returns a stateViewerType enum, either Scene or SceneGraph.
    virtual HOM_EnumValue &viewerType() = 0;

    virtual std::vector<HOM_ElemPtr<HOM_GeometryViewport> > viewports() = 0;
    SWIGOUT(%newobject findViewport;)
    virtual HOM_GeometryViewport *findViewport(const char *name) = 0;
    SWIGOUT(%newobject curViewport;)
    virtual HOM_GeometryViewport *curViewport() = 0;
    virtual HOM_GeometryViewport * selectedViewport() = 0;

    virtual std::string currentState() = 0;
    virtual void enterViewState(bool wait_for_exit = false) = 0;
    virtual void enterCurrentNodeState(bool wait_for_exit = false) = 0;
    virtual void enterTranslateToolState(bool wait_for_exit = false) = 0;
    virtual void enterRotateToolState(bool wait_for_exit = false) = 0;
    virtual void enterScaleToolState(bool wait_for_exit = false) = 0;
    SWIGOUT(%kwargs setCurrentState;)
    virtual void setCurrentState(const char *state, bool wait_for_exit = false,
                                 const HOM_EnumValue &generate =
                                                HOM_stateGenerateMode::Insert,
                                 bool request_new_on_generate = false,
                                 bool ex_situ_generate = false) = 0;
    virtual void _waitForStateExit(const char *state=NULL) = 0;
    virtual std::string _currentBaseState() = 0;

    virtual std::vector<std::string> _getCurrentStateParmNames() = 0;
    virtual std::string _evalCurrentStateParm(const char *name) = 0;
    virtual bool _setCurrentStateParm(const char *name, const char* value) =0;
    virtual bool _pressCurrentStateButton(const char *name)=0;

    virtual bool isCreateInContext() = 0;
    virtual bool isWorldSpaceLocal() = 0;

    virtual HOM_EnumValue& viewportLayout() = 0;
    virtual void setViewportLayout(HOM_EnumValue &layout, int single = -1) = 0;

    SWIGOUT(%kwargs selectObjects;)
    virtual std::vector<HOM_ElemPtr<HOM_Node> >
        selectObjects(
            const char *prompt = "Select objects",
            int sel_index = 0,
            bool allow_drag = false,
            bool quick_select = false,
            bool use_existing_selection = true,
            bool allow_multisel = true,
            const std::vector<std::string> &allowed_types =
                std::vector<std::string>(1, "*"),
            const char *icon = NULL,
            const char *label = NULL,
            const std::vector<std::string> &prior_selection_paths =
                std::vector<std::string>(),
            const std::vector<std::string> &prior_selection_ids =
                std::vector<std::string>(),
            const std::vector<HOM_Selection *> &prior_selections =
                std::vector<HOM_Selection *>(),
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            bool confirm_existing = false,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%newobject selectGeometry;)
    SWIGOUT(%kwargs selectGeometry;)
    virtual HOM_GeometrySelection *
        selectGeometry(
            const char *prompt = "Select geometry",
            int sel_index = 0,
            bool allow_drag = false,
            bool quick_select = false,
            bool use_existing_selection = true,
            const char *initial_selection = NULL,
            HOM_EnumValue *initial_selection_type = NULL,
            bool ordered = false,
            const std::vector<HOM_EnumValue *> geometry_types =
                std::vector<HOM_EnumValue *>(),
            const std::vector<HOM_EnumValue *> primitive_types =
                std::vector<HOM_EnumValue *>(),
            bool allow_obj_sel = true,
            const char *icon = NULL,
            const char *label = NULL,
            const std::vector<std::string> &prior_selection_paths =
                std::vector<std::string>(),
            const std::vector<std::string> &prior_selection_ids =
                std::vector<std::string>(),
            const std::vector<HOM_Selection *> &prior_selections =
                std::vector<HOM_Selection *>(),
            bool allow_other_sops = true,
            bool consume_selections = true,
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            bool confirm_existing = false,
            bool pick_at_obj_level = false,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%kwargs selectDynamics;)
    virtual std::vector<HOM_ElemPtr<HOM_DopData> >
        selectDynamics(
            const char *prompt = "Select dynamics objects",
            int sel_index = 0,
            bool allow_objects = true,
            bool allow_modifiers = false,
            bool quick_select = false,
            bool use_existing_selection = true,
            bool allow_multisel = true,
            const char *icon = NULL,
            const char *label = NULL,
            const std::vector<std::string> &prior_selection_paths =
                std::vector<std::string>(),
            const std::vector<std::string> &prior_selection_ids =
                std::vector<std::string>(),
            const std::vector<HOM_Selection *> &prior_selections =
                std::vector<HOM_Selection *>(),
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%kwargs selectDynamicsPoints;)
    virtual std::vector<std::pair<HOM_ElemPtr<HOM_DopData>,
                                  HOM_ElemPtr<HOM_GeometrySelection> > >
        selectDynamicsPoints(
            const char *prompt = "Select dynamics points",
            int sel_index = 0,
            bool quick_select = false,
            bool use_existing_selection = true,
            bool allow_multisel = true,
            bool only_select_points = true,
            bool object_based_point_selection = false,
            bool use_last_selected_object = false,
            const char *icon = NULL,
            const char *label = NULL,
            const std::vector<std::string> &prior_selection_paths =
                std::vector<std::string>(),
            const std::vector<std::string> &prior_selection_ids =
                std::vector<std::string>(),
            const std::vector<HOM_Selection *> &prior_selections =
                std::vector<HOM_Selection *>(),
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            const char *select_parm = nullptr
            )= 0;

    SWIGOUT(%kwargs selectDynamicsPolygons;)
    virtual std::vector<std::pair<HOM_ElemPtr<HOM_DopData>,
                                  HOM_ElemPtr<HOM_GeometrySelection> > >
        selectDynamicsPolygons(
            const char *prompt = "Select dynamics polygons",
            int sel_index = 0,
            bool quick_select = false,
            bool use_existing_selection = true,
            bool object_based_point_selection = false,
            bool use_last_selected_object = false,
            const char *icon = NULL,
            const char *label = NULL,
            const std::vector<std::string> &prior_selection_paths =
                std::vector<std::string>(),
            const std::vector<std::string> &prior_selection_ids =
                std::vector<std::string>(),
            const std::vector<HOM_Selection *> &prior_selections =
                std::vector<HOM_Selection *>(),
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%kwargs selectSceneGraph;)
    virtual std::vector<std::string>
        selectSceneGraph(
            const char *prompt = "Select primitives",
            const std::vector<std::string> &preselection =
                std::vector<std::string>(),
            const HOM_EnumValue &prim_mask= HOM_scenePrimMask::ViewerSetting,
            bool quick_select = false,
            bool use_existing_selection = true,
            bool confirm_existing = false,
            bool allow_multisel = true,
            bool allow_drag = true,
            bool allow_selection_type_changes = false,
            bool propagate_selection = true,
            const char *path_prefix_mask = nullptr,
            const char *prim_kind = nullptr,
            HOM_Node *validate_selection_for_node = nullptr,
            const char *select_parm = nullptr,
            const HOM_EnumValue &allow_kind_mismatch =
                HOM_optionalBool::NoOpinion,
            const HOM_EnumValue &allow_instance_proxies =
                HOM_optionalBool::NoOpinion,
            bool fix_preselection_paths = true
            ) = 0;

    SWIGOUT(%kwargs selectSceneGraphInstances;)
    virtual std::vector<std::string>
        selectSceneGraphInstances(
            const char *prompt = "Select point instances",
            const std::vector<std::string> &preselection =
                  std::vector<std::string>(),
            bool quick_select = false,
            bool use_existing_selection = true,
            bool confirm_existing = false,
            bool allow_multisel = true,
            bool allow_drag = true,
            bool allow_selection_type_changes = false,
            const char *path_prefix_mask = nullptr,
            int instance_level = 0,
            bool instance_indices_only = false,
            HOM_Node *validate_selection_for_node = nullptr,
            const char *select_parm = nullptr
            ) = 0;

        
    SWIGOUT(%newobject selectPositions;)
    SWIGOUT(%kwargs selectPositions;)
    virtual std::vector<HOM_ElemPtr<HOM_Vector3> >
        selectPositions(
            const char *prompt = "Click to specify a position",
            int number_of_positions = 1,
            int min_number_of_positions = -1,
            bool connect_positions = true,
            bool show_coordinates = true,
            const HOM_BoundingBox &bbox = HOM_BoundingBox(),
            HOM_EnumValue &position_type = HOM_positionType::WorldSpace,
            const char *icon = NULL,
            const char *label = NULL,
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%kwargs selectOrientedPositions;)
    virtual std::vector<std::pair<HOM_ElemPtr<HOM_Vector3>,
                                  HOM_ElemPtr<HOM_Matrix3> > >
        selectOrientedPositions(
            const char *prompt = "Click to specify a position",
            int number_of_positions = 1,
            int min_number_of_positions = -1,
            bool connect_positions = true,
            bool show_coordinates = true,
            const HOM_Matrix3 &base_orientation = HOM_Matrix3(1.0),
            const HOM_BoundingBox &bbox = HOM_BoundingBox(),
            const char *icon = NULL,
            const char *label = NULL,
            HOM_ParmTemplateGroup *toolbox_templategroup = nullptr,
            HOM_ParmTemplateGroup *toolbox1_templategroup = nullptr,
            const char *select_parm = nullptr
            ) = 0;

    SWIGOUT(%ignore _selectDrawableGeometry;)
    SWIGOUT(%kwargs _selectDrawableGeometry;)
    virtual void _selectDrawableGeometry(void* drawable_selection, HOM_EnumValue & selection_modifier) = 0;
#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs selectDrawableGeometry;)
    virtual void selectDrawableGeometry(InterpreterObject drawable_selection, 
                                        HOM_EnumValue & selection_modifier=HOM_pickModifier::Replace)
    {
        self->_selectDrawableGeometry(drawable_selection, selection_modifier);
    }
}
#endif


    SWIGOUT(%newobject currentGeometrySelection;)
    virtual HOM_GeometrySelection *currentGeometrySelection() = 0;
    virtual std::string currentGeometrySelectionParm() =0;

    virtual void setCurrentGeometrySelection(
            HOM_EnumValue &geometry_type,
            const std::vector<HOM_Node *> &nodes,
            const std::vector<HOM_Selection *> &selections) = 0;

    virtual std::vector<std::string> currentSceneGraphSelection() = 0;
    virtual void setCurrentSceneGraphSelection(
            const std::vector<std::string> &selection,
            bool fix_selection_paths = true) = 0;

    virtual std::vector<std::string> sceneGraphHighlight() = 0;
    virtual void setSceneGraphHighlight(const std::vector<std::string> &highlight) = 0;

    virtual UT_Tuple<double, std::string> locateSceneGraphPrim(
            int x, int y,
            const HOM_EnumValue &prim_mask =
                HOM_scenePrimMask::ViewerSetting) = 0;

    virtual bool sceneGraphStageLocked() = 0;
    virtual void setSceneGraphStageLocked(bool locked) = 0;

    // Snapping control
    virtual HOM_EnumValue &snappingMode() = 0;
    virtual void setSnappingMode(HOM_EnumValue &snapping_mode) = 0;

    virtual bool isSnappingToCurrentGeometry() = 0;
    virtual void setSnapToCurrentGeometry(bool on) = 0;

    virtual bool isSnappingToTemplates() = 0;
    virtual void setSnapToTemplates(bool on) = 0;

    virtual bool isSnappingToOtherObjects() = 0;
    virtual void setSnapToOtherObjects(bool on) = 0;

    virtual bool isSnappingToGuides() = 0;
    virtual void setSnapToGuides(bool on) = 0;

    virtual bool isSnappingToDrawables() = 0;
    virtual void setSnapToDrawables(bool on) = 0;

    virtual bool isDepthSnapping() = 0;
    virtual void setDepthSnapping(bool on) = 0;

    virtual bool isOrientingOnSnap() = 0;
    virtual void setOrientOnSnap(bool on) = 0;

    virtual float snappingGravity() = 0;
    virtual std::vector<HOM_EnumValue*> snappingPriorities() = 0;

    // Selection control
    virtual bool isPickingVisibleGeometry() = 0;
    virtual void setPickingVisibleGeometry(bool on) = 0;

    virtual bool isPickingContainedGeometry() = 0;
    virtual void setPickingContainedGeometry(bool on) = 0;
    
    virtual bool isGroupPicking() = 0;
    virtual void setGroupPicking(bool on) = 0;

    virtual bool isWholeGeometryPicking() = 0;
    virtual void setWholeGeometryPicking(bool on) = 0;

    virtual bool isSecureSelection() = 0;
    virtual void setSecureSelection(bool on) = 0;

    virtual bool isPickingCurrentNode() = 0;
    virtual void setPickingCurrentNode(bool on) = 0;

    virtual HOM_EnumValue &pickGeometryType() = 0;
    virtual void setPickGeometryType(HOM_EnumValue &geometry_type) = 0;

    virtual HOM_EnumValue &selectionMode() = 0;
    virtual void setSelectionMode(HOM_EnumValue &style) = 0;
    
    virtual HOM_EnumValue &pickStyle() = 0;
    virtual void setPickStyle(HOM_EnumValue &style) = 0;

    virtual HOM_EnumValue &pickModifier() = 0;
    virtual void setPickModifier(HOM_EnumValue &modifier) = 0;

    virtual HOM_EnumValue &defaultPickModifier() = 0;
    virtual void setDefaultPickModifier(HOM_EnumValue &modifier) = 0;

    virtual HOM_EnumValue &pickFacing() = 0;
    virtual void setPickFacing(HOM_EnumValue &facing) = 0;

    virtual HOM_EnumValue & activePickModifier() = 0;

    // Group list control
    virtual bool isGroupListVisible() = 0;
    virtual void setGroupListVisible(bool on) = 0;

    virtual bool isGroupListColoringGeometry() = 0;
    virtual void setGroupListColoringGeometry(bool on) = 0;

    virtual bool isGroupListShowingEmptyGroups() = 0;
    virtual void setGroupListShowingEmptyGroups(bool on) = 0;

    virtual bool isGroupListShowingOnlyPreSelectedGroups() = 0;
    virtual void setGroupListShowingOnlyPreSelectedGroups(bool on) = 0;

    virtual bool isGroupListCondensingPathHierarchies() = 0;
    virtual void setGroupListCondensingPathHierarchies(bool on) = 0;

    virtual HOM_Vector2 *groupListSize() = 0;
    virtual void setGroupListSize(double width, double height) = 0;

    virtual HOM_EnumValue &groupListType() = 0;
    virtual void setGroupListType(HOM_EnumValue &group_list_type) = 0;

    virtual std::string groupListMask() = 0;
    virtual void setGroupListMask(const char *mask) = 0;

    // Construction plane access
    SWIGOUT(%newobject constructionPlane;)
    virtual HOM_ConstructionPlane *constructionPlane() = 0;

    // Reference plane access
    SWIGOUT(%newobject referencePlane;)
    virtual HOM_ReferencePlane *referencePlane() = 0;

    SWIGOUT(%newobject flipbookSettings;)
    virtual HOM_FlipbookSettings *flipbookSettings() = 0;

    SWIGOUT(%kwargs flipbook;)
    virtual void flipbook(HOM_GeometryViewport *viewport = NULL,
                          HOM_FlipbookSettings *settings = NULL,
                          bool open_dialog = false) = 0;

    virtual void runShelfTool(const char *tool_name) = 0;

    virtual void beginStateUndo(const char *label) = 0;
    virtual void endStateUndo() = 0;

    virtual void setPromptMessage(
        std::string const & msg,
        HOM_EnumValue const & msg_type = HOM_promptMessageType::Prompt) = 0;
    virtual void clearPromptMessage() = 0;

    SWIGOUT(%kwargs flashmessage;)
    virtual void flashMessage(
        std::string const &image,
        std::string const &msg,
        float duration = 1.0,
        HOM_GeometryViewport *viewport = NULL) = 0;

    virtual std::vector<std::vector<std::string> >
        hotkeyAssignments(const std::vector<std::string> &hotkey_symbols) = 0;

    virtual void showHandle( std::string const& name, bool value ) = 0;

    virtual void openVisualizerEditor(HOM_ViewportVisualizer *vis) = 0;

    virtual void openOptionDialog(const char *path, const char *label) = 0;

    SWIGOUT(%kwargs triggerStateSelector;)
    virtual void triggerStateSelector(
        HOM_EnumValue const &action, 
        std::string const &name=std::string()) = 0;
    virtual std::string currentStateSelector() = 0;

    SWIGOUT(%ignore _runStateCommand;)
    SWIGOUT(%kwargs _runStateCommand;)
    virtual void _runStateCommand(std::string const & name, void* args=nullptr) = 0;

    virtual void showCurrentSopGeometry(bool value) = 0;
    virtual bool isShowingCurrentSopGeometry() const = 0;

    virtual bool toggleStateDialogWindow() = 0;

    virtual void showOperationBar(bool on) = 0 ;
    virtual bool isShowingOperationBar() = 0 ;

    virtual void showColorCorrectionBar(bool on) = 0 ;
    virtual bool isShowingColorCorrectionBar() = 0 ;

    virtual void showMemoryBar(bool on) = 0 ;
    virtual bool isShowingMemoryBar() = 0 ;

    virtual void showDisplayOptionsBar(bool on) = 0 ;
    virtual bool isShowingDisplayOptionsBar() = 0 ;

    virtual void showSelectionBar(bool on) = 0 ;
    virtual bool isShowingSelectionBar() = 0 ;

    virtual void setIncludeColorCorrectionBar(bool on) = 0 ;
    virtual bool includeColorCorrectionBar() = 0 ;

    virtual void setIncludeMemoryBar(bool on) = 0 ;
    virtual bool includeMemoryBar() = 0 ;

    virtual void setGeometryVisibility( HOM_OpNode &op, bool on ) = 0;
    virtual bool geometryVisibility( HOM_OpNode &op ) = 0;

    virtual bool usingOCIO() = 0;
    virtual void setUsingOCIO(bool enable) = 0;

    SWIGOUT(%kwargs setOCIODisplayView;)
    virtual void setOCIODisplayView(const char *display = nullptr,
                                    const char *view = nullptr) = 0;
    virtual std::string getOCIODisplay() = 0;
    virtual std::string getOCIOView() = 0;

    virtual std::vector<int> geometry() = 0;

    SWIGOUT(%newobject createFloatingViewport;)
    virtual HOM_GeometryViewport *createFloatingViewport(std::vector<int> size,
                                                         std::vector<int> pos)=0;

#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs runStateCommand;)
    virtual void runStateCommand(std::string const & name, InterpreterObject args=nullptr)
    {
        self->_runStateCommand(name, args);
    }
}
#endif

    // Scene graph specific.
    virtual bool isViewingSceneGraph() = 0;
#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs stage;)
    InterpreterObject stage()
    { return HOMincRef((InterpreterObject)self->opaqueStage()); }
}
#endif
    SWIGOUT(%ignore opaqueStage;)
    virtual void *opaqueStage() = 0;
    virtual int stageSerial() = 0;
    virtual void setShowGeometry(bool show) = 0;
    virtual bool showGeometry() = 0;
    virtual void setShowCameras(bool show) = 0;
    virtual bool showCameras() = 0;
    virtual void setShowLights(bool show) = 0;
    virtual bool showLights() = 0;
    virtual void setShowSelection(bool show) = 0;
    virtual bool showSelection() = 0;
    virtual void setShowRenderTime(bool show) = 0;
    virtual bool showRenderTime() = 0;
    virtual void setShowRenderStats(bool show) = 0;
    virtual bool showRenderStats() = 0;

    virtual void setSelectionKind(const char *kind) = 0;
    virtual void setSelectionPointInstances(bool topmost) = 0;
    virtual std::string selectionKind() = 0;
    virtual bool isSelectingPointInstances() = 0;
    virtual bool isSelectingTopmostInstance() = 0;
    virtual void setSelectionAllowKindMismatch(bool allow) = 0;
    virtual bool selectionAllowKindMismatch() = 0;
    virtual void setSelectionAllowInstanceProxies(bool allow) = 0;
    virtual bool selectionAllowInstanceProxies() = 0;
    virtual void setSelectionAllowHiddenPrims(bool allow) = 0;
    virtual bool selectionAllowHiddenPrims() = 0;

    virtual void setStageControlsPlaybar(bool controls_playbar) = 0;
    virtual bool stageControlsPlaybar() = 0;

    virtual std::vector<std::string> hydraRenderers() = 0;
    virtual void setHydraRenderer(const std::string &ren_name) = 0;
    virtual std::string currentHydraRenderer() = 0;
    virtual bool isRendererPaused() = 0;
    virtual void setRendererPaused(bool paused) = 0;
    virtual void restartRenderer() = 0;
    virtual void resetViewportCamera() = 0;

    SWIGOUT(%kwargs showProxyPurpose;)
    virtual void showProxyPurpose(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showGuidePurpose;)
    virtual void showGuidePurpose(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showRenderPurpose;)
    virtual void showRenderPurpose(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs useViewportOverrides;)
    virtual void useViewportOverrides(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs useViewportLoadMasks;)
    virtual void useViewportLoadMasks(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs usePostLayers;)
    virtual void usePostLayers(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showMaterials;)
    virtual void showMaterials(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showHydraProcedurals;)
    virtual void showHydraProcedurals(bool enable,
            const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showingProxyPurpose;)
    virtual bool showingProxyPurpose(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showingGuidePurpose;)
    virtual bool showingGuidePurpose(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showingRenderPurpose;)
    virtual bool showingRenderPurpose(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs usingViewportOverrides;)
    virtual bool usingViewportOverrides(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs usingViewportLoadMasks;)
    virtual bool usingViewportLoadMasks(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs usingPostLayers;)
    virtual bool usingPostLayers(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showingMaterials;)
    virtual bool showingMaterials(const char *renderer = nullptr) = 0;
    SWIGOUT(%kwargs showingHydraProcedurals;)
    virtual bool showingHydraProcedurals(const char *renderer = nullptr) = 0;

    SWIGOUT(%ignore addOpaqueEventCallback;)
    virtual void addOpaqueEventCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaqueEventCallback;)
    virtual void removeOpaqueEventCallback(void *callback) = 0;
    SWIGOUT(%ignore opaqueEventCallbacks;)
    virtual std::vector<void *> opaqueEventCallbacks() = 0;
    SWIGOUT(%ignore clearOpaqueEventCallbacks;)
    virtual void clearOpaqueEventCallbacks() = 0;

    virtual void setExtraCameras(const std::vector<std::string> &cam_names) = 0;
    virtual std::vector<std::string> extraCameras() = 0;

    static void pinCamera(const std::string &cam_name, bool pin)
                   { pinCameraFunc(cam_name, pin); }

    SWIGOUT(%ignore pinCameraFunc;)
    static UT_Functor2<void, const std::string &, bool> pinCameraFunc;

#ifdef SWIG
// expose the handling of the viewer callbacks to HOM
%extend
{
    void addEventCallback(InterpreterObject callback)
    {
        self->addOpaqueEventCallback(callback);
    }

    void removeEventCallback(InterpreterObject callback)
    {
        self->removeOpaqueEventCallback(callback);
    }

    void clearEventCallbacks()
    {
        self->clearOpaqueEventCallbacks();
    }

    std::vector<InterpreterObject> eventCallbacks()
    {
        std::vector<void *> opaque_callbacks(self->opaqueEventCallbacks());

        std::vector<InterpreterObject> callbacks;
        for (int i = 0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
        return callbacks;
    }
}
#endif

#ifdef SWIG
%extend
{
    InterpreterObject qtWindow()
    { 
        return (InterpreterObject)self->opaqueQtWindow(); 
    }
}
#endif

    SWIGOUT(%ignore opaqueQtWindow;)
    virtual void *opaqueQtWindow() = 0;

    // HUD info method
#ifdef SWIG
%extend
{
    SWIGOUT(%kwargs _hudInfo;)
    void _hudInfo(int show=-1, bool terminate=false, int update_texture=0,
                  const HOM_EnumValue &hud_state=HOM_hudInfoState::NoState,
                  InterpreterObject hud_template=nullptr,
                  InterpreterObject hud_values=nullptr,
                  const HOM_EnumValue& hud_panel=HOM_hudPanel::ToolInfo,
                  bool update_hotkey_bindings=false)
    {
        self->hudInfoInternal(hud_state, show, terminate, update_texture,
                              hud_template, hud_values, hud_panel,
                              update_hotkey_bindings);
    }
}
#endif
    SWIGOUT(%ignore hudInfoInternal;)
    virtual void hudInfoInternal(const HOM_EnumValue &hud_state, int show,
                                 bool terminate, int update_texture,
                                 void* hud_template, void* hud_values,
                                 const HOM_EnumValue& hud_panel,
                                 bool update_hotkey_bindings) = 0;

    SWIGOUT(%kwargs bindViewerHandle;)
    virtual void bindViewerHandle(
        std::string const&      handle_type, 
        std::string const&      handle_instance_name, 
        std::string const&      settings=std::string(),
        bool                    cache_previous_parms = false,
        HandleParmNames const&  handle_parms = HandleParmNames()) = 0;

    SWIGOUT(%kwargs bindViewerHandleStatic;)
    virtual void bindViewerHandleStatic(
        std::string const&  handle_type, 
        std::string const&  handle_instance_name, 
        Bindings const &    bindings,
        std::string const&  settings=std::string() ) = 0;

    virtual void unbindViewerHandle(std::string const& handle_instance_name) = 0;

    virtual std::string fullName() = 0;

    virtual void _setSlapComp(HOM_Node *node) = 0;

    virtual void _updateApexAnimateSceneIndex(
            const std::string &scene_prim_path,
            const std::map<std::string, HOM_Geometry *> &graph_outputs) = 0;
};

#endif