HDK: HOM/HOM_SceneViewer.h Source File

00001 /*
00002  * PROPRIETARY INFORMATION.  This software is proprietary to
00003  * Side Effects Software Inc., and is not to be reproduced,
00004  * transmitted, or disclosed in any way without written permission.
00005  *
00006  * Produced by:
00007  *      Side Effects Software Inc
00008  *      123 Front Street West, Suite 1401
00009  *      Toronto, Ontario
00010  *      Canada   M5J 2M2
00011  *      416-504-9876
00012  *
00013  * COMMENTS:
00014  */
00015 
00016 #ifndef __HOM_SceneViewer_h__
00017 #define __HOM_SceneViewer_h__
00018 
00019 #include "HOM_PathBasedPaneTab.h"
00020 #include "HOM_EnumModules.h"
00021 #include "HOM_BoundingBox.h"
00022 #include "HOM_Vector3.h"
00023 #include <vector>
00024 
00025 class HOM_DopData;
00026 class HOM_GeometryViewport;
00027 class HOM_GeometrySelection;
00028 class HOM_ParticleSelection;
00029 
00030 SWIGOUT(%rename(SceneViewer) HOM_SceneViewer;)
00031 
00032 class HOM_API HOM_SceneViewer : virtual public HOM_PathBasedPaneTab
00033 {
00034 public:
00035     HOM_SceneViewer()
00036     { HOM_CONSTRUCT_OBJECT(this) }
00037 
00038     // Because the lowermost base classes initialize the virtual bases
00039     // before any non-virtual bases, the correct thing to do here is
00040     // explicitly call the constructor for HOM_PaneTab.
00041     HOM_SceneViewer(const HOM_SceneViewer &pane)
00042     : HOM_PaneTab(pane), HOM_PathBasedPaneTab(pane)
00043     { HOM_CONSTRUCT_OBJECT(this) }
00044 
00045     virtual ~HOM_SceneViewer()
00046     { HOM_DESTRUCT_OBJECT(this) }
00047 
00048     // Let swig know we're overriding __repr__ for this class so it doesn't
00049     // provide its own __repr__.
00050     SWIGOUT(virtual std::string __repr__()
00051         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;)
00052 
00053     SWIGPYTHONOUT(%feature("autodoc",
00054         "viewports(self) -> tuple of GeometryViewports") viewports;)
00055     virtual std::vector<HOM_ElemPtr<HOM_GeometryViewport> > viewports()
00056         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00057     SWIGOUT(%newobject findViewport;)
00058     virtual HOM_GeometryViewport *findViewport(const char *name)
00059         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00060     virtual HOM_GeometryViewport *curViewport()
00061         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00062 
00063     virtual std::string currentState()
00064         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00065     virtual void enterViewState(bool wait_for_exit = false)
00066         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00067             HOM_OperationInterrupted, HOM_Error) = 0;
00068     virtual void enterCurrentNodeState(bool wait_for_exit = false)
00069         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00070             HOM_OperationInterrupted, HOM_Error) = 0;
00071     virtual void enterTranslateToolState(bool wait_for_exit = false)
00072         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00073               HOM_OperationInterrupted, HOM_Error) = 0;
00074     virtual void enterRotateToolState(bool wait_for_exit = false)
00075         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00076               HOM_OperationInterrupted, HOM_Error) = 0;
00077     virtual void enterScaleToolState(bool wait_for_exit = false)
00078         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00079               HOM_OperationInterrupted, HOM_Error) = 0;
00080     virtual void setCurrentState(const char *state, bool wait_for_exit = false)
00081         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationFailed,
00082             HOM_OperationInterrupted, HOM_Error) = 0;
00083 
00084     virtual bool isCreateInContext() throw(HOM_NotAvailable, 
00085                                            HOM_ObjectWasDeleted,
00086                                            HOM_Error) = 0;
00087 
00088     SWIGPYTHONOUT(%feature("autodoc",
00089         "viewportLayout(self) -> "
00090         " hou.geometryViewportLayout enum value") viewportLayout;)
00091     virtual HOM_EnumValue& viewportLayout()
00092         throw(HOM_ObjectWasDeleted, HOM_Error) = 0;
00093     virtual void setViewportLayout(HOM_EnumValue &layout, int single = -1)
00094         throw(HOM_ObjectWasDeleted, HOM_TypeError, HOM_Error) = 0;
00095 
00096     SWIGPYTHONOUT(%feature("autodoc",
00097         "selectObjects(self,"
00098             " prompt='Select objects',"
00099             " sel_index=0,"
00100             " allow_drag=False,"
00101             " quick_select=False,"
00102             " use_existing_selection=True,"
00103             " allow_multisel=True,"
00104             " allowed_types=('*',),"
00105             " icon=None,"
00106             " label=None"
00107             ") -> tuple of Nodes") selectObjects;)
00108     SWIGOUT(%kwargs selectObjects;)
00109     virtual std::vector<HOM_ElemPtr<HOM_Node> > selectObjects(
00110             const char *prompt = "Select objects",
00111             int sel_index = 0,
00112             bool allow_drag = false,
00113             bool quick_select = false,
00114             bool use_existing_selection = true,
00115             bool allow_multisel = true,
00116             const std::vector<std::string> &allowed_types =
00117                 std::vector<std::string>(1, "*"),
00118             const char *icon = NULL,
00119             const char *label = NULL)
00120         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00121               HOM_Error) = 0;
00122 
00123     SWIGPYTHONOUT(%feature("autodoc",
00124         "selectGeometry(self,"
00125             " prompt='Select geometry',"
00126             " sel_index=0,"
00127             " allow_drag=False,"
00128             " quick_select=False,"
00129             " use_existing_selection=True,"
00130             " ordered=False,"
00131             " connected=False,"
00132             " geometry_types=(),"
00133             " primitive_types=(),"
00134             " allow_obj_sel=True,"
00135             " icon=None,"
00136             " label=None"
00137             ") -> GeometrySelection") selectGeometry;)
00138     SWIGOUT(%newobject selectGeometry;)
00139     SWIGOUT(%kwargs selectGeometry;)
00140     virtual HOM_GeometrySelection *selectGeometry(
00141             const char *prompt = "Select geometry",
00142             int sel_index = 0,
00143             bool allow_drag = false,
00144             bool quick_select = false,
00145             bool use_existing_selection = true,
00146             bool ordered = false,
00147             bool connected = false,
00148             const std::vector<HOM_EnumValue *> geometry_types =
00149                 std::vector<HOM_EnumValue *>(),
00150             const std::vector<HOM_EnumValue *> primitive_types =
00151                 std::vector<HOM_EnumValue *>(),
00152             bool allow_obj_sel = true,
00153             const char *icon = NULL,
00154             const char *label = NULL)
00155         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00156               HOM_TypeError, HOM_Error) = 0;
00157 
00158     SWIGPYTHONOUT(%feature("autodoc",
00159         "selectDynamics(self,"
00160             " prompt='Select dynamics objects',"
00161             " sel_index=0,"
00162             " allow_objects=True,"
00163             " allow_modifiers=False,"
00164             " quick_select=False,"
00165             " use_existing_selection=True,"
00166             " allow_multisel=True,"
00167             " icon=None,"
00168             " label=None"
00169             ") -> tuple of DopData") selectDynamics;)
00170     SWIGOUT(%kwargs selectDynamics;)
00171     virtual std::vector<HOM_ElemPtr<HOM_DopData> > selectDynamics(
00172             const char *prompt = "Select dynamics objects",
00173             int sel_index = 0,
00174             bool allow_objects = true,
00175             bool allow_modifiers = false,
00176             bool quick_select = false,
00177             bool use_existing_selection = true,
00178             bool allow_multisel = true,
00179             const char *icon = NULL,
00180             const char *label = NULL)
00181         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00182               HOM_Error) = 0;
00183 
00184     SWIGPYTHONOUT(%feature("autodoc",
00185         "selectDynamicsPoints(self,"
00186             " prompt='Select dynamics points',"
00187             " sel_index=0,"
00188             " quick_select=False,"
00189             " use_existing_selection=True,"
00190             " allow_multisel=True,"
00191             " only_select_points=True,"
00192             " icon=None,"
00193             " label=None"
00194             ") -> tuple of DopData, GeometrySelection pair") selectDynamicsPoints;)
00195     SWIGOUT(%kwargs selectDynamicsPoints;)
00196     virtual std::vector<std::pair<HOM_ElemPtr<HOM_DopData>, HOM_ElemPtr<HOM_GeometrySelection> > > selectDynamicsPoints(
00197             const char *prompt = "Select dynamics points",
00198             int sel_index = 0,
00199             bool quick_select = false,
00200             bool use_existing_selection = true,
00201             bool allow_multisel = true,
00202             bool only_select_points = true,
00203             const char *icon = NULL,
00204             const char *label = NULL)
00205         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00206               HOM_Error) = 0;
00207 
00208     SWIGPYTHONOUT(%feature("autodoc",
00209         "selectParticles(self,"
00210             " prompt='Select particles',"
00211             " sel_index=0,"
00212             " select_connected=True,"
00213             " quick_select=False,"
00214             " use_existing_selection=True,"
00215             " allow_multisel=True,"
00216             " icon=None,"
00217             " label=None"
00218             ") -> ParticleSelection") selectParticles;)
00219     SWIGOUT(%newobject selectParticles;)
00220     SWIGOUT(%kwargs selectParticles;)
00221     virtual HOM_ParticleSelection *selectParticles(
00222             const char *prompt = "Select particles",
00223             int sel_index = 0,
00224             bool select_connected = true,
00225             bool quick_select = false,
00226             bool use_existing_selection = true,
00227             bool allow_multisel = true,
00228             const char *icon = NULL,
00229             const char *label = NULL)
00230         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00231               HOM_Error) = 0;
00232 
00233     SWIGPYTHONOUT(%feature("autodoc",
00234         "selectParticleNodes(self,"
00235             " prompt='Select particle nodes',"
00236             " sel_index=0,"
00237             " allow_generators=True,"
00238             " allow_modifiers=False,"
00239             " quick_select=False,"
00240             " use_existing_selection=True,"
00241             " allow_multisel=True,"
00242             " icon=None,"
00243             " label=None"
00244             ") -> ParticleSelection") selectParticleNodes;)
00245     SWIGOUT(%newobject selectParticleNodes;)
00246     SWIGOUT(%kwargs selectParticleNodes;)
00247     virtual HOM_ParticleSelection *selectParticleNodes(
00248             const char *prompt = "Select particle nodes",
00249             int sel_index = 0,
00250             bool allow_generators = true,
00251             bool allow_modifiers = false,
00252             bool quick_select = false,
00253             bool use_existing_selection = true,
00254             bool allow_multisel = true,
00255             const char *icon = NULL,
00256             const char *label = NULL)
00257         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00258               HOM_Error) = 0;
00259 
00260     SWIGPYTHONOUT(%feature("autodoc",
00261         "selectPositions(self,"
00262             " prompt='Click to specify a position',"
00263             " number_of_positions=1,"
00264             " connect_positions=True,"
00265             " show_coordinates=True,"
00266             " bbox=BoundingBox(),"
00267             " position_type=positionType.WorldSpace,"
00268             " icon=None,"
00269             " label=None"
00270             ") -> tuple of Vector3s") selectPositions;)
00271     SWIGOUT(%newobject selectPositions;)
00272     SWIGOUT(%kwargs selectPositions;)
00273     virtual std::vector<HOM_ElemPtr<HOM_Vector3> > selectPositions(
00274             const char *prompt = "Click to specify a position",
00275             int number_of_positions = 1,
00276             bool connect_positions = true,
00277             bool show_coordinates = true,
00278             const HOM_BoundingBox &bbox = HOM_BoundingBox(),
00279             HOM_EnumValue &position_type = HOM_positionType::WorldSpace,
00280             const char *icon = NULL,
00281             const char *label = NULL)
00282         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_OperationInterrupted,
00283               HOM_TypeError, HOM_Error) = 0;
00284 
00285     SWIGPYTHONOUT(%feature("autodoc",
00286         "snappingMode(self) -> hou.snappingMode enum value") snappingMode;)
00287     virtual HOM_EnumValue &snappingMode()
00288         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00289 
00290     virtual void setSnappingMode(HOM_EnumValue &snapping_mode)
00291         throw(HOM_TypeError, HOM_NotAvailable, HOM_ObjectWasDeleted,
00292             HOM_Error) = 0;
00293 
00294     virtual bool isSnappingToTemplates()
00295         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00296     virtual void setSnapToTemplates(bool on)
00297         throw(HOM_OperationFailed, HOM_NotAvailable, HOM_ObjectWasDeleted,
00298             HOM_Error) = 0;
00299 
00300     virtual bool isSnappingToOtherObjects()
00301         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00302     virtual void setSnapToOtherObjects(bool on)
00303         throw(HOM_OperationFailed, HOM_NotAvailable, HOM_ObjectWasDeleted,
00304             HOM_Error) = 0;
00305 
00306     virtual bool isDepthSnapping()
00307         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00308     virtual void setDepthSnapping(bool on)
00309         throw(HOM_OperationFailed, HOM_NotAvailable, HOM_ObjectWasDeleted,
00310             HOM_Error) = 0;
00311 
00312     virtual bool isOrientingOnSnap()
00313         throw(HOM_NotAvailable, HOM_ObjectWasDeleted, HOM_Error) = 0;
00314     virtual void setOrientOnSnap(bool on)
00315         throw(HOM_OperationFailed, HOM_NotAvailable, HOM_ObjectWasDeleted,
00316             HOM_Error) = 0;
00317 };
00318 
00319 #endif