HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HOM_Module.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * COMMENTS:
7  * This class is not directly wrapped by swig. However, when creating
8  * the swig wrapper modules we wrap each of the methods of this class
9  * in functions in $SHC/HOM/HOM_TopLevel.h. This way, the methods of this
10  * class appear as the top-level parts of the hou module.
11  * Note that this also means SWIGOUT(%newobject fooMethod;) directives are
12  * not here but in HOM_TopLevel.h instead.
13  */
14 
15 #ifndef __HOM_Module_h__
16 #define __HOM_Module_h__
17 
18 #include "HOM_API.h"
19 #include "HOM_BinaryString.h"
20 #include "HOM_Defines.h"
21 #include "HOM_Errors.h"
22 #include "HOM_ElemPtr.h"
23 #include "HOM_EnumModules.h"
25 #include <UT/UT_Lock.h>
26 #include <UT/UT_NonCopyable.h>
27 #include <UT/UT_Notifier.h>
28 #include <UT/UT_TaskLock.h>
29 #include <UT/UT_Thread.h>
30 #include <UT/UT_UniquePtr.h>
31 #include <UT/UT_OptionEntry.h>
32 #include <SYS/SYS_Types.h>
33 #include <typeinfo>
34 #include <string>
35 #include <vector>
36 #include <map>
37 #include <hboost/any.hpp>
38 
39 class OP_Node;
40 class STORUI_OrboltURLHandler;
41 
43 class HOM_AgentClip;
45 class HOM_AgentLayer;
46 class HOM_AgentMetadata;
47 class HOM_AgentRig;
48 class HOM_AgentShape;
53 class HOM_ApexNode;
55 class HOM_ApexStickyNote;
57 class HOM_AttribDataId;
58 class HOM_anim;
59 class HOM_anonstats;
60 class HOM_audio;
62 class HOM_ChannelPrim;
63 class HOM_ChopNode;
64 class HOM_Clip;
65 class HOM_clone;
66 class HOM_Color;
67 class HOM_crowds;
69 class HOM_SimpleDrawable;
70 class HOM_dop;
71 class HOM_DopData;
72 class HOM_DopSimulation;
73 class HOM_Edge;
74 class HOM_EnumValue;
78 class HOM_GadgetContext;
79 class HOM_GadgetDrawable;
80 class HOM_galleries;
81 class HOM_Geometry;
84 class HOM_GUDetailHandle;
85 class HOM_Handle;
86 class HOM_hda;
87 class HOM_HDADefinition;
88 class HOM_HDAModule;
89 class HOM_HDAOptions;
90 class HOM_hipFile;
91 class HOM_hmath;
92 class HOM_ik;
95 class HOM_Keyframe;
97 class HOM_logging;
101 class HOM_lop;
105 class HOM_Matrix4;
107 class HOM_NetworkBox;
108 class HOM_NetworkDot;
110 class HOM_Node;
111 class HOM_NodeBundle;
112 class HOM_NodeConnection;
113 class HOM_NodeType;
116 class HOM_Parm;
117 class HOM_ParmTemplate;
119 class HOM_ParmTuple;
120 class HOM_perfMon;
122 class HOM_pypanel;
123 class HOM_playbar;
125 class HOM_Point;
126 class HOM_Prim;
127 class HOM_properties;
128 class HOM_qt;
130 class HOM_RedrawBlock;
131 #ifndef SWIG
133 #endif
134 class HOM_SceneViewer;
136 class HOM_Selection;
138 class HOM_shelves;
139 class HOM_StickyNote;
140 class HOM_StringKeyframe;
142 class HOM_styles;
143 class HOM_StyleSheet;
145 class HOM_takes;
146 class HOM_text;
147 class HOM_TextDrawable;
149 class HOM_ui;
150 class HOM_hotkeys;
151 class HOM_UIEvent;
152 class HOM_UIEventDevice;
153 class HOM_undos;
154 class HOM_Vector3;
155 class HOM_Vertex;
156 class HOM_VexContext;
157 class HOM_ViewerEvent;
159 class HOM_ViewerDragger;
165 class HOM_ViewerStateMenu;
169 
170 #define HOM_SESSION_MODULE_NAME "hou.session"
171 #define HOM_SESSION_MODULE_CPIO_NAME "." HOM_SESSION_MODULE_NAME
172 
173 // Use this function to access the HOM module from C++ in Houdini. This
174 // is equivalent to writing "hou" in python. It will only throw an exception
175 // if the python module could not be imported, which should not happen.
176 class HOM_Module;
178 
180 {
181 public:
182  static void setHOMCreator(void (*homCreator)());
183 
184  virtual ~HOM_Module() {}
185 
186  virtual std::vector<std::string> _getArgumentAutoComplete(
187  const char *method_name, const char *arguments,
188  bool meta_info_only = false) = 0;
189 
190  // This method is called by the expression editor to force autocompletion
191  // to be relative to the node containing the expression. It is not
192  // wrapped by swig.
193  virtual void setRelativeNodeForAutoComplete(OP_Node *node) = 0;
194 
195  virtual HOM_ui& ui() = 0;
196  virtual HOM_qt& qt() = 0;
197  virtual HOM_hotkeys& hotkeys() = 0;
198  virtual HOM_audio& audio() = 0;
199  virtual bool isUIAvailable() = 0;
200  virtual bool _isExperimentalActive() = 0;
201  virtual bool _isCurrentThreadHoldingHOMLock() = 0;
202 
203  virtual HOM_galleries& galleries() = 0;
204  virtual HOM_hda& hda() = 0;
205  virtual HOM_hipFile& hipFile() = 0;
206  virtual HOM_perfMon& perfMon() = 0;
207  virtual HOM_playbar& playbar() = 0;
208  virtual HOM_pypanel& pypanel() = 0;
209  virtual HOM_hmath& hmath() = 0;
210  virtual HOM_dop& dop() = 0;
211  virtual HOM_properties& properties() = 0;
212  virtual HOM_shelves& shelves() = 0;
213  virtual HOM_styles& styles() = 0;
214  virtual HOM_takes& takes() = 0;
215  virtual HOM_undos& undos() = 0;
216  virtual HOM_viewportVisualizers& viewportVisualizers() = 0;
217  virtual HOM_anim& anim() = 0;
218  virtual HOM_anonstats& anonstats() = 0;
219  virtual HOM_clone& clone() = 0;
220  virtual HOM_crowds& crowds() = 0;
221  virtual HOM_ik& ik() = 0;
222  virtual HOM_logging& logging() = 0;
223  virtual HOM_lop& lop() = 0;
224  virtual HOM_text& text() = 0;
225 
226  virtual bool _assertWrapper(
227  const char *file, int linenum, const char *function,
228  const char *condition, const char *reason) = 0;
229 
230  virtual void exit(int exit_code=0, bool suppress_save_prompt=false) = 0;
231 
232  // isExiting() will return true if the program is actually Houdini (not
233  // mplay) and the UI queue is closed. This method is wrapped by swig, but
234  // only so houdiniInterpreter can call it.
235  virtual bool isExiting() = 0;
236 
237  virtual void addPreloadIcon(const char *name, int w, int h) = 0;
238  virtual void rasterizePreloadIcons() = 0;
239 
240  virtual std::string applicationName() = 0;
241  virtual std::vector<int> applicationVersion(bool include_patch=false) = 0;
242  virtual std::string applicationVersionString() = 0;
243  virtual std::string applicationCompilationDate() = 0;
244  virtual std::string applicationPlatformInfo() = 0;
245  virtual std::map<std::string, std::string> vdbVersionInfo() = 0;
246  virtual int hdkAPIVersion() = 0;
247  virtual HOM_EnumValue &licenseCategory() = 0;
248  virtual bool isApprentice() = 0;
249  virtual void releaseLicense() = 0;
250 
251  // Threading controls
252  virtual int maxThreads() = 0;
253  virtual void setMaxThreads(int max_threads) = 0;
254 
255  // These methods return a new HOM_Node object.
256  virtual HOM_Node* root() = 0;
257  virtual HOM_Node* pwd() = 0;
258  virtual HOM_Node* parent() = 0;
259 
260  virtual void setPwd(HOM_Node &newpwd) = 0;
261  virtual void cd(const char *path) = 0;
262 
263  // Calling phm() is a shortcut for calling pwd().hdaModule().
264  virtual HOM_HDAModule* phm() = 0;
265 
266  // This method returns a new HOM_DopNetNode object or None.
267  virtual HOM_Node* currentDopNet() = 0;
268  virtual void setCurrentDopNet(HOM_Node &dopnet) = 0;
269 
270  // Gets or sets the simulation enabled state.
271  virtual bool simulationEnabled() = 0;
272  virtual void setSimulationEnabled(bool enabled) = 0;
273 
274  // These methods return a new HOM_Node object or null if the node couldn't
275  // be found.
276  virtual HOM_Node *node(const char *path) = 0;
277  virtual HOM_NetworkMovableItem* item(const char *path) = 0;
278 
279  virtual std::vector<HOM_ElemPtr<HOM_Node> > nodes(const std::vector<std::string> &paths) = 0;
280  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > items(const std::vector<std::string> &paths) = 0;
281 
282  virtual HOM_Node *nodeBySessionId(int session_id) = 0;
283  virtual HOM_NetworkBox *networkBoxBySessionId(int session_id) = 0;
284  virtual HOM_StickyNote *stickyNoteBySessionId(int session_id) = 0;
285  virtual HOM_SubnetIndirectInput *subnetIndirectInputBySessionId(
286  int64 session_id) = 0;
287  virtual HOM_NetworkDot *networkDotBySessionId(int session_id) = 0;
288  virtual HOM_NetworkMovableItem *itemBySessionId(
289  HOM_EnumValue &item_type, int64 session_id) = 0;
290  virtual HOM_NodeConnection *nodeConnectionBySessionId(
291  int node_session_id, int input_index) = 0;
292 
293  // Functions for APEX nodes.
294  virtual HOM_ApexNode *createApexRootNode() = 0;
295  virtual HOM_ApexNode *apexNodeBySessionId(
296  int64 session_id) = 0;
297  virtual HOM_ApexNodeConnection *apexNodeConnectionBySessionId(
298  int64 session_id) = 0;
299  virtual HOM_ApexStickyNote *apexStickyNoteBySessionId(
300  int64 session_id) = 0;
301 
302  // Functions for configuring default colors on network elements.
303  virtual HOM_Color defaultColor(HOM_EnumValue &color_item) = 0;
304  virtual void setDefaultColor(HOM_EnumValue &color_item, HOM_Color *color) = 0;
305 
306  // Return HOM_Nodes for all selected nodes in the session.
307  virtual std::vector<HOM_ElemPtr<HOM_Node> > selectedNodes(
308  bool include_hidden = false) = 0;
309  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > selectedItems(
310  bool include_hidden = false) = 0;
311  virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> > selectedConnections() = 0;
312  virtual void clearAllSelected() = 0;
313 
314  // Copy nodes to and paste from clipboard.
315  virtual void copyNodesToClipboard(const std::vector<HOM_Node *> &nodes) = 0;
316  virtual void pasteNodesFromClipboard(HOM_Node &destination_node) = 0;
317 
318  // These methods return new HOM_Parm/HOM_ParmTuple objects or null if the
319  // parm couldn't be found.
320  virtual HOM_Parm* parm(const char *path) = 0;
321  SWIGOUT(%ignore newParm;)
322  virtual HOM_Parm* newParm(OP_Node &node, int parm_index, int vector_index) = 0;
323  virtual HOM_ParmTuple* parmTuple(const char *path) = 0;
324  virtual HOM_Parm *evaluatingParm() = 0;
325 
326  // The next methods are not wrapped by swig, and are used
327  // by the HOM_ChannelList to manage geometry channel collections.
328  // These are necessary as the HOM_ChannelList does not have
329  // an implementation at the HOMF level, and cannot directly access
330  // Nodes, GU_Details or the MOT_GeometryChannelManager.
331 
332  // This method asks the MOT_GeometryChannelManager for a new
333  // geometry channel collection name, ensuring uniqueness.
334  SWIGOUT(%ignore reserveNewGeometryCollectionName;)
335  virtual UT_StringHolder reserveNewGeometryCollectionName() = 0;
336  // This method accesses the GU_Detail to get the names of geometry channels,
337  // so they can be stored in the HOM_ChannelList.
338  SWIGOUT(%ignore geometryChannelNames;)
339  virtual UT_StringArray geometryChannelNames(
341 
342  // Returns the path of a node from its unique id.
343  // Used by the HOM_ChannelList.
344  SWIGOUT(%ignore getNodePathFromNodeId;)
345  virtual UT_StringHolder getNodePathFromNodeId(int id) = 0;
346 
347  // Fetch the list of channel primitives in a geometry. Used
348  // by HOM_ChannelList to display channel primitives added to the
349  // channel list
350  SWIGOUT(%ignore getChannelPrims;)
351  virtual std::vector<HOM_ElemPtr<HOM_ChannelPrim>> getChannelPrims(
352  HOM_GUDetailHandle *gdh,
353  const UT_StringHolder &pattern) = 0;
354 
355  virtual HOM_ScriptEvalContext * newScriptEvalContext(HOM_Node &node) = 0;
356  virtual HOM_ScriptEvalContext * newScriptEvalContext(HOM_Parm &parm) = 0;
357 
358  // Access to the contents of the parm clipboard
359  virtual std::vector< std::map<std::string, std::string> >
360  parmClipboardContents() = 0;
361 
362  // These methods return a new HOM_NodeType object or null if it couldn't
363  // be found.
364  virtual HOM_NodeType *nodeType(
365  HOM_NodeTypeCategory &category, const char *name) = 0;
366  virtual HOM_NodeType *nodeType(const char *name) = 0;
367 
368  virtual HOM_NodeType *preferredNodeType(
369  const char *name, HOM_Node *parentNode = NULL) = 0;
370 
371  virtual HOM_NodeTypeCategory &objNodeTypeCategory() = 0;
372  virtual HOM_NodeTypeCategory &sopNodeTypeCategory() = 0;
373  virtual HOM_NodeTypeCategory &dopNodeTypeCategory() = 0;
374  virtual HOM_NodeTypeCategory &cop2NodeTypeCategory() = 0;
375  virtual HOM_NodeTypeCategory &copNodeTypeCategory() = 0;
376  virtual HOM_NodeTypeCategory &shopNodeTypeCategory() = 0;
377  virtual HOM_NodeTypeCategory &vopNodeTypeCategory() = 0;
378  virtual HOM_NodeTypeCategory &ropNodeTypeCategory() = 0;
379  virtual HOM_NodeTypeCategory &chopNodeTypeCategory() = 0;
380  virtual HOM_NodeTypeCategory &topNodeTypeCategory() = 0;
381  virtual HOM_NodeTypeCategory &lopNodeTypeCategory() = 0;
382  virtual HOM_NodeTypeCategory &cop2NetNodeTypeCategory() = 0;
383  virtual HOM_NodeTypeCategory &vopNetNodeTypeCategory() = 0;
384  virtual HOM_NodeTypeCategory &chopNetNodeTypeCategory() = 0;
385  virtual HOM_NodeTypeCategory &topNetNodeTypeCategory() = 0;
386  virtual HOM_NodeTypeCategory &managerNodeTypeCategory() = 0;
387  virtual HOM_NodeTypeCategory &rootNodeTypeCategory() = 0;
388  virtual HOM_NodeTypeCategory &dataNodeTypeCategory() = 0;
389  virtual std::map<std::string, HOM_NodeTypeCategory *>
390  nodeTypeCategories() = 0;
391  virtual HOM_NodeTypeCategory &apexNodeTypeCategory() = 0;
392 
393  virtual std::vector<HOM_ElemPtr<HOM_Node> > copyNodesTo(
394  const std::vector<HOM_Node *> &nodes,
395  HOM_Node &destination_node) = 0;
396  virtual std::vector<HOM_ElemPtr<HOM_Node> > moveNodesTo(
397  const std::vector<HOM_Node *> &nodes,
398  HOM_Node &destination_node) = 0;
399 
400  virtual HOM_NodeBundle *addNodeBundle(const char *name = NULL) = 0;
401  virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > nodeBundles() = 0;
402  virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > selectedNodeBundles() = 0;
403  virtual HOM_NodeBundle *nodeBundle(const char *name) = 0;
404 
405  virtual HOM_HDADefinition *hdaDefinition(
406  HOM_NodeTypeCategory &category, const char *name,
407  const char *file_path) = 0;
408 
409  // Note that getTimeWithoutAddingDependency is not wrapped by swig.
410  virtual fpreal getTimeWithoutAddingDependency() = 0;
411  virtual double time() = 0;
412  virtual void setTime(double time) = 0;
413  virtual double frame(bool full_precision=false) = 0;
414  virtual int intFrame() = 0;
415  virtual void setFrame(double frame) = 0;
416  virtual double fps() = 0;
417  virtual void setFps(
418  double fps,
419  bool modify_frame_count = true,
420  bool preserve_keyframes = false,
421  bool preserve_frame_start = false)
422  = 0;
423  virtual double timeToFrame(double time, bool full_precision=false) = 0;
424  virtual double frameToTime(double frame) = 0;
425 
426  /// Private methods for ensuring that the current eval context
427  /// (including global time) is in-sync with the main thread's eval
428  /// context.
429  virtual void _syncFromMainContext() = 0;
430  virtual void _syncToMainContext() = 0;
431 
432  // Computes a scale factor given units
433  virtual fpreal scaleFromMKS(const char *units) = 0;
434  virtual fpreal scaleToMKS(const char *units) = 0;
435 
436  virtual double bezier() = 0;
437  virtual double constant() = 0;
438  virtual double cubic() = 0;
439  virtual double cycle(double start_frame, double end_frame) = 0;
440  virtual double cyclet(double start_time, double end_time) = 0;
441  virtual double cycleoffset(double start_frame, double end_frame) = 0;
442  virtual double cycleoffsett(double start_time, double end_time) = 0;
443  virtual double ease() = 0;
444  virtual double easein() = 0;
445  virtual double easeinp(double ease_speed) = 0;
446  virtual double easeout() = 0;
447  virtual double easeoutp(double ease_speed) = 0;
448  virtual double easep(double ease_bias) = 0;
449  virtual double linear() = 0;
450  virtual double match() = 0;
451  virtual double matchin() = 0;
452  virtual double matchout() = 0;
453  virtual double qlinear() = 0;
454  virtual double quintic() = 0;
455  virtual double repeat(double start_frame, double end_frame) = 0;
456  virtual double repeatt(double start_time, double end_time) = 0;
457  virtual double spline() = 0;
458  virtual double vmatch() = 0;
459  virtual double vmatchin() = 0;
460  virtual double vmatchout() = 0;
461 
462  virtual std::string chopExportConflictResolutionPattern() = 0;
463  virtual void setChopExportConflictResolutionPattern( const char *pattern) = 0;
464 
465  virtual std::vector<HOM_ElemPtr<HOM_VexContext> >
466  vexContexts() = 0;
467 
468  virtual HOM_VexContext* vexContextForShaderType(HOM_EnumValue &shader_type) = 0;
469 
470  virtual HOM_VexContext* vexContextForNodeTypeCategory(
471  HOM_NodeTypeCategory &node_type_category) = 0;
472 
473  virtual std::string helpServerUrl() = 0;
474 
475  virtual std::string hscriptCommandHelp(const char *command_name) = 0;
476 
477  // This method returns a pair of strings: one for stdout and one for
478  // stderr.
479  virtual std::vector<std::string> hscript(const char *command) = 0;
480 
481  // Compare if two numbers are almost equal.
482  virtual bool almostEqual(double x, double y) = 0;
483 
484  virtual std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> >
485  fileReferences(
486  const char *project_dir_variable="HIP", bool include_all_refs=true) = 0;
487 
488  // Find files in $HOUDINI_PATH.
489  virtual std::string findFile(const char *file_name) = 0;
490  virtual std::vector<std::string> findFiles(
491  const char *file_name) = 0;
492  virtual std::vector<std::string> findFilesWithExtension(
493  const char *file_extension, const char *subdirectory = NULL) = 0;
494 
495  // Find directories in $HOUDINI_PATH.
496  virtual std::string findDirectory(const char *directory_name) = 0;
497  virtual std::vector<std::string> findDirectories(
498  const char *directory_name) = 0;
499 
500  virtual std::vector<std::string> houdiniPath(const char *pathvar = nullptr) = 0;
501 
502  virtual std::string homeHoudiniDirectory() = 0;
503 
504  virtual std::string readFile(const char *file_path) = 0;
505  virtual HOM_BinaryString readBinaryFile(const char *file_path) = 0;
506 
507  virtual std::map<std::string, HOM_BinaryString> loadIndexDataFromString(
508  const char *data, int length) = 0;
509 
510  virtual std::map<std::string, HOM_BinaryString> loadIndexDataFromFile(
511  const char *file_path) = 0;
512 
513  virtual HOM_BinaryString saveIndexDataToString(
514  const std::map<std::string, HOM_BinaryString> &index_data) = 0;
515 
516  virtual void saveIndexDataToFile(
517  const char *file_path,
518  const std::map<std::string, HOM_BinaryString> &index_data) = 0;
519 
520  // Note that, when wrapped by swig, this function takes a single string
521  // parameter.
522  virtual std::vector<std::pair<std::string, HOM_BinaryString> >
523  loadCPIODataFromString(const char *data, int length) = 0;
524 
525  virtual HOM_BinaryString saveCPIODataToString(
526  const std::vector<std::pair<std::string, HOM_BinaryString> >
527  &data) = 0;
528 
529  // These 3 methods are not wrapped by swig. They are used to notify
530  // interested parties that a change to the module source code was made and
531  // that they should forcefully update to match the change. The third
532  // is used to load the session module source from a hip file, even though
533  // that source might generate an exception.
534  virtual UT_NotifierImpl<int> &getSessionModuleSourceForceUpdateNotifier()=0;
535  virtual void forceUpdateFromSessionModuleSource() = 0;
536  virtual void forceSetSessionModuleSource(const char *source) = 0;
537 
538  virtual void setSessionModuleSource(const char *source) = 0;
539  virtual void appendSessionModuleSource(const char *source) = 0;
540  virtual std::string sessionModuleSource() = 0;
541  // This method is not wrapped by swig:
542  virtual int sessionModuleSourceChangeCount() = 0;
543 
544  // This static method lets you know if the HOM implementation is set,
545  // so you can check if it's safe to call the HOM() function. This method
546  // should only be called in rare cases.
547  static bool isImplementationSet()
548  { return theImplementation != NULL; }
549 
550  // Evaluates a parameter as if it was an OPpath parameter
551  virtual std::string chsop(const char *path) = 0;
552 
553  // Evaluates a parameter as if it was an OPlist parameter
554  virtual std::string chsoplist(const char *path) = 0;
555 
556  // Sorts a list of node paths using topological order from the graph.
557  virtual std::vector<std::string>
558  sortedNodePaths(const std::vector<std::string> &paths) = 0;
559 
560  // Sorts a list of HOM_Node using topological order from the graph.
561  virtual std::vector<HOM_ElemPtr<HOM_Node> >
562  sortedNodes(const std::vector<HOM_Node*> &nodes) = 0;
563 
564  // deprecated in favour of hou.text.patternMatch
565  virtual int patternMatch(
566  const char *pattern, const char *str,
567  bool ignore_case = false,
568  bool path_match = false) = 0;
569 
570  // hscriptExpression() will return different types, according to
571  // the return value of the expression.
572  virtual hboost::any hscriptExpression(const char *expression) = 0;
573  virtual double hscriptFloatExpression(const char *expression) = 0;
574  virtual std::string hscriptStringExpression(const char *expression) = 0;
575  virtual std::vector<double>hscriptVectorExpression(
576  const char *expression) = 0;
577  virtual std::vector<std::vector<double> > hscriptMatrixExpression(
578  const char *expression) = 0;
579 
580  virtual hboost::any lvar(const char *name) = 0;
581 
582  virtual char *getEnvConfigValue(
583  const char *name, const char *default_value=NULL) = 0;
584 
585  virtual char *getenv(const char *name, const char *default_value=NULL) = 0;
586 
587  virtual void putenv(const char *name, const char *value) = 0;
588 
589  virtual void unsetenv(const char *name) = 0;
590 
591  virtual void allowEnvironmentToOverwriteVariable(
592  const char *name, bool onoff) = 0;
593 
594  virtual void *expressionGlobals() = 0;
595 
596  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
597 
598  // This method is used to interact with the global interrupt object.
599  virtual bool updateProgressAndCheckForInterrupt(int percentage=-1) = 0;
600 
601  virtual std::map<std::string, hboost::any> runVex(
602  const char *vex_file,
603  const std::map<std::string, hboost::any> &inputs,
604  const char *precision = "32") = 0;
605 
606  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
607 
608  virtual void saveImageDataToFile(
609  const std::vector<float> &color_and_alpha_data,
610  int width, int height,
611  const char *file_name) = 0;
612 
613  virtual void saveImageDataToFile(
614  const std::string &color_and_alpha_data,
615  int width, int height,
616  const char *file_name) = 0;
617 
618  virtual HOM_BinaryString loadImageDataFromFile(
619  const char *image_file_name,
620  HOM_EnumValue &image_depth = HOM_imageDepth::Int8) = 0;
621 
622  virtual std::vector<int> imageResolution(const char *image_file_name) = 0;
623 
624  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
625 
626  virtual HOM_EnumValue &updateModeSetting() = 0;
627  virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
628 
629  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
630 
631  virtual HOM_OrboltURLHandler *orboltURLHandler() = 0;
632 
633  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
634 
635  virtual void *opaqueRunCallbackAndCatchCrashes(void *opaque_callback) = 0;
636 
637  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
638 
639  // These methods are used to grant functions defined in an asset's
640  // PythonModule enhanced privileges. They are not wrapped by swig.
641  virtual void pushAccessPrivilege(const char *key) = 0;
642  virtual void popAccessPrivilege(const char *key) = 0;
643 
644  virtual std::string currentPythonModuleKey() = 0;
645 
646  virtual void registerAccessPrivilegePyClient(void *opaque_python_object) = 0;
647 
648  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
649 
650  // These methods are used to instantiate HOMF objects from the HOM
651  // library level. They are not wrapped by swig.
652  virtual HOM_FloatParmTemplate *newFloatParmTemplate(
653  const char *name,
654  const char *label,
655  int num_components,
656  const std::vector<double> &default_value,
657  double min, double max,
658  bool min_is_strict, bool max_is_strict,
659  HOM_EnumValue &look,
660  HOM_EnumValue &naming_scheme,
661  const char *disable_when,
662  bool is_hidden,
663  bool is_label_hidden,
664  bool join_with_next,
665  const char *help,
666  const char *script_callback,
667  HOM_EnumValue &script_callback_language,
668  const std::map<std::string, std::string> &tags,
669  const std::map<HOM_EnumValue *, std::string> &conditionals,
670  const std::vector<std::string> &default_expression,
671  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
672 
673  virtual HOM_IntParmTemplate *newIntParmTemplate(
674  const char *name,
675  const char *label,
676  int num_components,
677  const std::vector<int64> &default_value,
678  int64 min, int64 max,
679  bool min_is_strict, bool max_is_strict,
680  HOM_EnumValue &look,
681  HOM_EnumValue &naming_scheme,
682  const std::vector<std::string> &menu_items,
683  const std::vector<std::string> &menu_labels,
684  const std::vector<std::string> &icon_names,
685  const std::string &item_generator_script,
686  HOM_EnumValue *item_generator_script_language,
687  HOM_EnumValue &menu_type,
688  bool menu_use_token,
689  const char *disable_when,
690  bool is_hidden,
691  bool is_label_hidden,
692  bool join_with_next,
693  const char *help,
694  const char *script_callback,
695  HOM_EnumValue &script_callback_language,
696  const std::map<std::string, std::string> &tags,
697  const std::map<HOM_EnumValue *, std::string> &conditionals,
698  const std::vector<std::string> &default_expression,
699  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
700 
701  virtual HOM_StringParmTemplate *newStringParmTemplate(
702  const char *name,
703  const char *label,
704  int num_components,
705  const std::vector<std::string> &default_value,
706  HOM_EnumValue &naming_scheme,
708  HOM_EnumValue &file_type,
709  const std::vector<std::string> &menu_items,
710  const std::vector<std::string> &menu_labels,
711  const std::vector<std::string> &icon_names,
712  const std::string &item_generator_script,
713  HOM_EnumValue *item_generator_script_language,
714  HOM_EnumValue &menu_type,
715  const char *disable_when,
716  bool is_hidden,
717  bool is_label_hidden,
718  bool join_with_next,
719  const char *help,
720  const char *script_callback,
721  HOM_EnumValue &script_callback_language,
722  const std::map<std::string, std::string> &tags,
723  const std::map<HOM_EnumValue *, std::string> &conditionals,
724  const std::vector<std::string> &default_expression,
725  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
726 
727  virtual HOM_DataParmTemplate *newDataParmTemplate(
728  const char *name,
729  const char *label,
730  int num_components,
731  HOM_EnumValue &look,
732  HOM_EnumValue &naming_scheme,
733  HOM_EnumValue &data_parm_type,
734  const char *disable_when,
735  bool is_hidden,
736  bool is_label_hidden,
737  bool join_with_next,
738  const char *help,
739  const char *script_callback,
740  HOM_EnumValue &script_callback_language,
741  const std::map<std::string, std::string> &tags,
742  const std::map<HOM_EnumValue *, std::string> &conditionals,
743  const std::vector<std::string> &default_expression,
744  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
745 
746  virtual HOM_ToggleParmTemplate *newToggleParmTemplate(
747  const char *name,
748  const char *label,
749  bool default_value,
750  const char *disable_when,
751  bool is_hidden,
752  bool is_label_hidden,
753  bool join_with_next,
754  const char *help,
755  const char *script_callback,
756  HOM_EnumValue &script_callback_language,
757  const std::map<std::string, std::string> &tags,
758  const std::map<HOM_EnumValue *, std::string> &conditionals,
759  const std::string &default_expression,
760  const HOM_EnumValue &default_expression_language) = 0;
761 
762  virtual HOM_MenuParmTemplate *newMenuParmTemplate(
763  const char *name,
764  const char *label,
765  const std::vector<std::string> &menu_items,
766  const std::vector<std::string> &menu_labels,
767  int64 default_value,
768  const std::vector<std::string> &icon_names,
769  const std::string &item_generator_script,
770  HOM_EnumValue *item_generator_script_language,
771  HOM_EnumValue &menu_type,
772  bool menu_use_token,
773  const char *disable_when,
774  bool is_hidden,
775  bool is_label_hidden,
776  bool join_with_next,
777  const char *help,
778  const char *script_callback,
779  HOM_EnumValue &script_callback_language,
780  const std::map<std::string, std::string> &tags,
781  const std::map<HOM_EnumValue *, std::string> &conditionals,
782  const std::string &default_expression,
783  const HOM_EnumValue &default_expression_language,
784  bool store_default_value_as_string,
785  bool is_button_strip,
786  bool strip_uses_icons
787  ) = 0;
788 
789  virtual HOM_ButtonParmTemplate *newButtonParmTemplate(
790  const char *name,
791  const char *label,
792  const char *disable_when,
793  bool is_hidden,
794  bool is_label_hidden,
795  bool join_with_next,
796  const char *help,
797  const char *script_callback,
798  HOM_EnumValue &script_callback_language,
799  const std::map<std::string, std::string> &tags,
800  const std::map<HOM_EnumValue *, std::string> &conditionals ) = 0;
801 
802  virtual HOM_LabelParmTemplate *newLabelParmTemplate(
803  const char *name,
804  const char *label,
805  const std::vector<std::string> &column_labels,
806  HOM_EnumValue &label_parm_type,
807  bool is_hidden,
808  bool is_label_hidden,
809  bool join_with_next,
810  const char *help,
811  const std::map<std::string, std::string> &tags,
812  const std::map<HOM_EnumValue *, std::string> &conditionals) = 0;
813 
814  virtual HOM_SeparatorParmTemplate *newSeparatorParmTemplate(
815  const char *name,
816  bool is_hidden,
817  const std::map<std::string, std::string> &tags,
818  const std::map<HOM_EnumValue *, std::string> &conditionals) = 0;
819 
820  virtual HOM_FolderSetParmTemplate *newFolderSetParmTemplate(
821  const char *name,
822  const std::vector<std::string> &folder_names,
823  HOM_EnumValue &folder_type,
824  const std::map<std::string, std::string> &tags) = 0;
825 
826  virtual HOM_FolderParmTemplate *newFolderParmTemplate(
827  const char *name,
828  const char *label,
829  const std::vector<HOM_ParmTemplate *> &parm_templates,
830  HOM_EnumValue &folder_type,
831  int default_value,
832  bool is_hidden,
833  bool ends_tab_group,
834  const char *script_callback,
835  HOM_EnumValue &script_callback_language,
836  const std::map<std::string, std::string> &tags,
837  const std::map<HOM_EnumValue *, std::string> &conditionals,
838  const std::map<HOM_EnumValue *, std::string> &tab_conditionals) = 0;
839 
840  virtual HOM_RampParmTemplate *newRampParmTemplate(
841  const char *name,
842  const char *label,
843  HOM_EnumValue &ramp_parm_type,
844  int default_value,
845  HOM_EnumValue *default_basis,
846  bool show_controls,
847  HOM_EnumValue *color_type,
848  const char *disable_when,
849  bool is_hidden,
850  const char *help,
851  const char *script_callback,
852  HOM_EnumValue &script_callback_language,
853  const std::map<std::string, std::string> &tags,
854  const std::map<HOM_EnumValue *, std::string> &conditionals,
855  const std::string &default_expression,
856  const HOM_EnumValue &default_expression_language) = 0;
857 
858  virtual HOM_ParmTemplateGroup *newParmTemplateGroup(
859  const std::vector<HOM_ParmTemplate *> &parm_templates) = 0;
860 
861  virtual HOM_PerfMonRecordOptions *newPerfMonRecordOptions(
862  bool cook_stats, bool pdg_cook_stats, bool solve_stats,
863  bool draw_stats, bool gpu_draw_stats, bool viewport_stats,
864  bool script_stats, bool render_stats, bool thread_stats,
865  bool frame_stats, bool memory_stats, bool errors,
866  bool pane_stats) = 0;
867 
868  virtual HOM_Keyframe *newKeyframe() = 0;
869  virtual HOM_Keyframe *newKeyframe(double value) = 0;
870  virtual HOM_Keyframe *newKeyframe(double value, double time) = 0;
871  virtual HOM_Keyframe *newKeyframe(const HOM_Keyframe &keyframe) = 0;
872 
873  virtual HOM_StringKeyframe *newStringKeyframe() = 0;
874  virtual HOM_StringKeyframe *newStringKeyframe(
875  const std::string &value, HOM_EnumValue &language) = 0;
876  virtual HOM_StringKeyframe *newStringKeyframe(
877  const std::string &value, double time, HOM_EnumValue &language) = 0;
878  virtual HOM_StringKeyframe *newStringKeyframe(
879  const HOM_StringKeyframe &string_keyframe) = 0;
880 
881  virtual HOM_HDAOptions *newHDAOptions() = 0;
882  virtual HOM_LopViewportLoadMasks *newLopViewportLoadMasks() = 0;
883  virtual HOM_LopInstanceIdRule *newLopInstanceIdRule() = 0;
884  virtual HOM_LopSelectionRule *newLopSelectionRule(
885  const char *pattern = nullptr) = 0;
886 
887  virtual HOM_InterruptableOperation *newInterruptableOperation(
888  const char *operation_name, const char *long_operation_name,
889  bool open_interrupt_dialog) = 0;
890 
891  virtual HOM_RedrawBlock *newRedrawBlock() = 0;
892 #ifndef SWIG
893  virtual HOM_RedrawResumeBlock *newRedrawResumeBlock() = 0;
894 #endif
895 
896  virtual HOM_StyleSheet *newStyleSheet() = 0;
897  virtual HOM_StyleSheet *newStyleSheet(const char *json_text) = 0;
898 
899  virtual HOM_Selection *newSelection(HOM_EnumValue &selection_type,
900  HOM_Geometry *geo, const char *selection_string) = 0;
901  virtual HOM_Selection *newSelection(
902  const std::vector<HOM_EnumValue *> &selection_types,
903  HOM_Geometry *geo, const char *selection_string) = 0;
904  virtual HOM_Selection *newSelection(
905  const std::vector<HOM_Prim *> &prims) = 0;
906  virtual HOM_Selection *newSelection(
907  const std::vector<HOM_Point *> &points) = 0;
908  virtual HOM_Selection *newSelection(
909  const std::vector<HOM_Vertex *> &vertices) = 0;
910  virtual HOM_Selection *newSelection(
911  const std::vector<HOM_Edge *> &edges) = 0;
912 
913  // This method returns a new HOM_Geometry object.
914  virtual HOM_Geometry *newGeometry(HOM_Geometry *geo = nullptr,
915  bool clone_data_ids = false) = 0;
916 
917  virtual HOM_GeometryRayCache *newGeometryRayCache() = 0;
918 
919  virtual HOM_DopSimulation *newDopSimulation() = 0;
920 
921  virtual HOM_Clip *newClip() = 0;
922 
923  virtual HOM_AgentDefinition *newAgentDefinition(
924  const HOM_AgentRig *rig, const HOM_AgentShapeLibrary *shapelib) = 0;
925 
926  virtual HOM_AgentClip *newAgentClip(
927  const char *name, const char *path, const HOM_AgentRig &rig,
928  bool keep_external_ref, bool delay_load) = 0;
929 
930  virtual HOM_AgentClip *newAgentClip(
931  const char *name, HOM_ChopNode &chop, const HOM_AgentRig &rig,
932  double frame) = 0;
933 
934  virtual HOM_AgentClip *newAgentClip(
935  const char *name, const HOM_AgentRig &rig, int sample_count) = 0;
936 
937  virtual HOM_AgentClip *newAgentClip(
938  const HOM_AgentClip &clip, const HOM_AgentRig &rig,
939  const char *name) = 0;
940 
941  virtual HOM_AgentClip *newAgentClip(
942  const char *name,
943  void *stage,
944  const char *prim_path,
945  const HOM_AgentRig &rig) = 0;
946 
947  virtual HOM_AgentRig *newAgentRig(const char *path, bool keep_external_ref) = 0;
948 
949  virtual HOM_AgentRig *newAgentRig(
950  const char *name, const std::vector<std::string> &transform_names,
951  const std::vector<std::vector<int>> &hierarchy) = 0;
952 
953  virtual HOM_AgentTransformGroup *newAgentTransformGroup(
954  const char *path, const HOM_AgentRig &rig,
955  bool keep_external_ref = true) = 0;
956 
957  virtual HOM_AgentTransformGroup *newAgentTransformGroup(
958  const char *name, const std::vector<int> &transforms,
959  const HOM_AgentRig &rig, const std::vector<double> &weights,
960  const std::vector<int> &channels) = 0;
961 
962  virtual HOM_AgentShapeLibrary *newAgentShapeLibrary() = 0;
963  virtual HOM_AgentShapeLibrary *newAgentShapeLibrary(
964  HOM_Geometry &geometry, const char *name) = 0;
965  virtual HOM_AgentShapeLibrary *newAgentShapeLibrary(
966  const char *path, bool keep_external_ref) = 0;
967 
968  virtual HOM_AgentShapeBinding *
969  newAgentShapeBinding(int transform, const HOM_AgentShape &shape,
970  bool deforming, double bounds_scale) = 0;
971 
972  virtual HOM_AgentShapeBinding *
973  newAgentShapeBinding(int transform, const HOM_AgentShape &shape,
974  const HOM_AgentShapeDeformer *deformer,
975  const HOM_Vector3 &bounds_scale) = 0;
976 
977  virtual HOM_AgentShapeDeformer *
978  newAgentShapeDeformer(const char *name) = 0;
979 
980  virtual HOM_AgentShapeDeformer *
981  newAgentShapeDeformer(const HOM_EnumValue &deformer_type) = 0;
982 
983  virtual HOM_AgentLayer *newAgentLayer(
984  const char *name, const HOM_AgentRig &rig,
985  const HOM_AgentShapeLibrary &shapelib,
986  const std::vector<HOM_AgentShapeBinding *> &shape_bindings,
987  const HOM_AgentLayer *source_layer = 0) = 0;
988 
989  virtual HOM_AgentLayer *
990  newAgentLayer(const char *path, const HOM_AgentRig &rig,
991  const HOM_AgentShapeLibrary &shapelib,
992  bool keep_external_ref = true) = 0;
993 
994  virtual HOM_AgentMetadata *newAgentMetadata(
995  const char *path,
996  bool keep_external_ref = true) = 0;
997  virtual HOM_AgentMetadata *newAgentMetadata(
998  const std::map<std::string, hboost::any> &data) = 0;
999 
1000  virtual bool compareNode(const char *path, const char *dest = NULL) = 0;
1001  virtual bool compareNodeBackup(const char *path, int index,
1002  const char *dest = NULL) = 0;
1003  virtual bool compareHDA(const char *path_left, const char *path_right,
1004  const char *dest = NULL) = 0;
1005  virtual bool compareHDABackup(const char *path, int index,
1006  const char *dest = NULL) = 0;
1007  virtual bool compareHip(const char *dest = NULL) = 0;
1008  virtual bool compareHipBackup(int index, const char *dest = NULL) = 0;
1009 
1010  virtual bool hasContextOption(const char *opt) = 0;
1011  virtual UT_OptionEntryPtr contextOption(const char *opt) = 0;
1012  virtual std::vector<std::string> contextOptionNames() = 0;
1013  virtual void setContextOption(const char *opt, const char *value) =0;
1014  virtual void setContextOption(const char *opt, double value) = 0;
1015  virtual void removeContextOption(const char *opt) = 0;
1016  virtual std::string contextOptionConfig(const char *opt) = 0;
1017  virtual void setContextOptionConfig(const char *opt,
1018  const char *config) = 0;
1019  virtual bool isAutoContextOption(const char *opt) = 0;
1020  virtual bool isAutoContextOptionOverridden(const char *opt) = 0;
1021 
1022  SWIGOUT(%ignore addOpaqueContextOptionChangeCallback;)
1023  virtual void addOpaqueContextOptionChangeCallback(void *callback) = 0;
1024  SWIGOUT(%ignore removeOpaqueContextOptionChangeCallback;)
1025  virtual void removeOpaqueContextOptionChangeCallback(void *callback) = 0;
1026  virtual void removeAllContextOptionChangeCallbacks() = 0;
1027  SWIGOUT(%ignore opaqueContextOptionChangeCallbacks;)
1028  virtual std::vector<void *> opaqueContextOptionChangeCallbacks() = 0;
1029 
1030  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1031 
1032  // This method is called when orbolt_url runs. It is not wrapped by swig.
1033  virtual void setOrboltURLHandler(
1034  STORUI_OrboltURLHandler &orbolt_url_handler) = 0;
1035 
1036  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1037 
1038  // These methods are used to help debug HOM to make sure no objects
1039  // get allocated that don't get deallocated.
1040  virtual void constructObject(void *pointer, const std::type_info &type) = 0;
1041  virtual void destructObject(void *pointer, const std::type_info &type) = 0;
1042  virtual std::map<std::string, int> objectCounts() = 0;
1043 
1044  // Preferences
1045  virtual std::vector<std::string> getPreferenceNames() = 0;
1046  virtual std::string getPreference(const char *name) = 0;
1047  virtual bool setPreference(const char *name, const char* value) = 0;
1048  virtual bool addPreference(const char *name, const char* value) = 0;
1049  virtual bool removePreference(const char *name) = 0;
1050  virtual void refreshPreferences() = 0;
1051 
1052  virtual HOM_ViewerStateTemplate * newViewerStateTemplate(
1053  std::string const & type_name,
1054  std::string const & label,
1055  HOM_NodeTypeCategory const & category,
1056  std::vector<HOM_NodeTypeCategory*> const & contexts) = 0;
1057 
1058  virtual HOM_ViewerHandleTemplate * newViewerHandleTemplate(
1059  std::string const & type_name,
1060  std::string const & label,
1061  std::vector<HOM_NodeTypeCategory*> const & categories) = 0;
1062 
1063  virtual HOM_ViewerStateMenu * newViewerStateMenu(std::string const & handle, std::string const & label) = 0;
1064 
1065  virtual HOM_PluginHotkeyDefinitions * newPluginHotkeyDefinitions() = 0;
1066 
1067  virtual HOM_SimpleDrawable * newSimpleDrawable( HOM_SceneViewer& scene_viewer, HOM_EnumValue const &prim_type, std::string const &name) = 0;
1068  virtual HOM_SimpleDrawable * newSimpleDrawable( HOM_SceneViewer& scene_viewer, HOM_Geometry const &geometry, std::string const &name) = 0;
1069 
1070  virtual HOM_ViewerHandleDragger * newViewerHandleDragger(std::string const & name) = 0;
1071  virtual HOM_ViewerStateDragger * newViewerStateDragger(std::string const & name, HOM_Matrix4 const & xform, HOM_Matrix4 const & inv_xform) = 0;
1072 
1073  virtual HOM_UIEvent * newUIEvent( int64 val, int64 val2 ) = 0;
1074  virtual HOM_ViewerEvent * newViewerEvent( HOM_SceneViewer& sceneViewer, int64 val, int64 val2 ) = 0;
1075  virtual HOM_UIEventDevice * newUIEventDevice(int64 val, int64 val2, int64 val3) = 0;
1076 
1077  virtual HOM_Handle * newHandle(HOM_SceneViewer& scene_viewer, std::string const &name ) = 0;
1078  virtual HOM_ViewerHandleContext * newViewerHandleContext(int64 val) = 0;
1079 
1080  virtual HOM_ViewerStateContext * newViewerStateContext(int64 val) = 0;
1081 
1082  virtual HOM_TextDrawable * newTextDrawable(
1083  HOM_SceneViewer& scene_viewer,
1084  std::string const & name,
1085  std::map<std::string, hboost::any> const & params,
1086  std::string const & label) = 0;
1087 
1088  virtual HOM_GeometryDrawable * newGeometryDrawable(
1089  HOM_SceneViewer& scene_viewer,
1090  HOM_EnumValue const & geo_type,
1091  std::string const & name,
1092  HOM_Geometry * geometry,
1093  std::map<std::string, hboost::any> const & params,
1094  std::string const & label) = 0;
1095 
1096  virtual HOM_GeometryDrawableGroup* newGeometryDrawableGroup(std::string const & name, std::string const & label) = 0;
1097 
1098  virtual HOM_GadgetDrawable * newGadgetDrawable(int64 widget, int64 gadget_context) = 0;
1099 
1100  virtual void startHoudiniEngineDebugger(unsigned short port) = 0;
1101  virtual void startHoudiniEngineDebugger(const char *pipe_name) = 0;
1102 
1103  virtual HOM_GeometrySelection * newGeometrySelection() = 0;
1104  virtual HOM_GeometrySelection * newGeometrySelection(int64 val) = 0;
1105 
1106  virtual HOM_logging_MemorySink * newMemorySink() = 0;
1107  virtual HOM_logging_FileSink * newFileSink(const char *filepath) = 0;
1108 
1109  virtual HOM_BinaryString convertClipData(HOM_BinaryString data,
1110  bool from_binary,
1111  bool from_blosc_compression,
1112  bool to_binary,
1113  bool to_blosc_compression) = 0;
1114 
1115  virtual HOM_BinaryString convertKeyframesToClipData(
1116  const std::map<std::string, std::vector<HOM_Keyframe *>> &keyframe_map,
1117  bool binary = true, bool use_blosc_compression = true) = 0;
1118 
1119  virtual std::string _clipInfo(HOM_BinaryString data, bool binary = true,
1120  bool blosc_compressed = true) = 0;
1121 
1122  virtual std::vector<HOM_ElemPtr<HOM_Node> > _nodesFromOPNodeList(int64 val) = 0;
1123  virtual std::vector<HOM_ElemPtr<HOM_DopData> >
1124  _dopDataList(int64 val) = 0;
1125  virtual std::vector<std::pair<HOM_ElemPtr<HOM_DopData>, HOM_ElemPtr<HOM_GeometrySelection> > >
1126  _dopDataPointList(int64 val) = 0;
1127  virtual std::vector<std::pair<HOM_ElemPtr<HOM_DopData>, HOM_ElemPtr<HOM_GeometrySelection> > >
1128  _dopDataPolyList(int64 val) = 0;
1129 
1130  virtual HOM_AttribDataId * newAttribDataId() = 0;
1131 
1132  virtual std::string userName(bool alpha=true) = 0;
1133 
1134  virtual std::string machineName(bool alpha=true) = 0;
1135 
1136  virtual HOM_GeometryDrawable * _newGeometryDrawable(int64 val) = 0;
1137 
1138  virtual HOM_Node * createAnimationLayers(const std::string &path) = 0;
1139  virtual HOM_Node * addAnimationLayer(HOM_Node &layermixer, const std::string &layername) = 0;
1140  virtual bool removeAnimationLayer(HOM_Node &layermixer, const std::string &layername, bool merge=false) = 0;
1141  virtual HOM_Node* createAnimationClip(const std::string &path, bool set_export) = 0;
1142 
1143  virtual void* _sceneViewerWindow(int64 val) = 0;
1144 
1145  virtual void registerOpdefPath(
1146  const std::string &path,
1147  const std::string &server_name,
1148  const std::string &port_name)
1149  = 0;
1150 
1151  virtual std::vector<std::string> videoEncoders(
1152  HOM_EnumValue const &driver, const bool available=false) = 0;
1153 
1154 private:
1155  // HOMF_Module::createHOMModule() uses this to create the HOM_Module.
1156  static void (*theHOMCreator)();
1157 
1158  // A subclass of HOM_Module in the HOMF library will define the
1159  // implementation of HOM. Importing the python module will set the
1160  // implementation, so this function should only be called by HOMF_Module::
1161  // createHOMModule().
1162  friend class HOMF_Module;
1163  static void setImplementation(HOM_Module* implementation);
1164 
1165  // We could add a static method to access the implementation, but we
1166  // want to make it easy to access the HOM module from C++. So, the
1167  // global function HOM() needs access to the implementation.
1168  friend HOM_API HOM_Module& HOM();
1169  static HOM_Module *theImplementation;
1170 };
1171 
1172 
1173 // Use this function to automatically delete objects for functions that
1174 // return new objects. This lets you, for example, write code like
1175 // HOMdel(HOM().findNode("/obj/geo1"))->setName("geo2")
1176 template <typename T>
1178 { return UT_UniquePtr<T>(hom_object); }
1179 
1180 
1181 // This lock is used to synchronize HOM scripts running in a separate
1182 // thread and Houdini. Houdini's UI queue will give up the lock when it's
1183 // waiting for events and reacquire it when it handles an event.
1184 //
1185 // Note that this lock allows multiple threads in the same thread group to hold
1186 // it at the same time. By default, a thread started from Houdini is added to
1187 // the group containing the main thread. This way, since Houdini started the
1188 // thread, we can be confident that it will use other locks to synchronize
1189 // access to Houdini. This approach allows, for example, a volume SOP to
1190 // cook using multiple threads, evaluating Python in each thread while the
1191 // main thread holds the HOM lock, without deadlocking and without allowing
1192 // non-Houdini threads to acquire the HOM lock. (Note that the GIL will
1193 // synchronize access to Python's internals.)
1196 {
1197  // This is not thread-safe but should be ok because HOMgetLock() is called
1198  // pretty early on during startup when there is only one thread executing.
1199  if (!HOM_theHOMLock)
1200  HOM_theHOMLock = new UT_TaskRootLock();
1201 
1202  UT_ASSERT(HOM_theHOMLock);
1203  return *HOM_theHOMLock;
1204 }
1205 
1206 // The HOM implementation uses the HOM_AutoLock to make sure Houdini isn't busy
1207 // when they make calls into the Houdini libraries. Note that constructing
1208 // a HOM_AutoLock will release the python global interpreter lock (GIL) if
1209 // it was held before acquiring the HOM lock. This way, other python threads
1210 // can run if it needs to block waiting for the HOM lock.
1212 {
1213 public:
1215  {
1216  if (!HOMgetLock().hasLock())
1217  {
1218  HOMgetLock().lock();
1219  myLocked = true;
1220  }
1221  else
1222  myLocked = false;
1223  }
1224 
1226  {
1227  if (myLocked)
1228  HOMgetLock().unlock();
1229  }
1230 
1231 private:
1232 
1233  // It is important that we release the python global interpreter lock
1234  // (GIL) for the duration of waiting for, acquiring and holding onto
1235  // the HOM lock. This gives other threads that are either blocked
1236  // on the GIL or that will try to acquire the GIL a chance to continue
1237  // execution.
1238  //
1239  // If the current thread needs to access the Python API,
1240  // then it should explicitly acquire the GIL by creating a
1241  // PY_InterpreterAutoLock object. The PY_InterpreterAutoLock must be
1242  // constructed *after* the HOM_AutoLock or it will have no effect.
1243  //
1244  // This prevents deadlocks that occur when the current thread
1245  // spawns other threads which access the Python API and try to
1246  // acquire the GIL.
1247  //
1248  // Note that we will reacquire the GIL when the HOM auto lock is destructed.
1249  PY_InterpreterAutoUnlock myPyInterpAutoUnlock;
1250 
1251  // Boolean to determine if the auto lock actually locked the HOM lock.
1252  bool myLocked;
1253 };
1254 
1255 // The HOM implementation uses HOM_AutoUnlock to allow the main thread to
1256 // run while waiting for something to happen. Constructing a HOM_AutoUnlock
1257 // instance will release the HOM lock but not the Python GIL. When it's
1258 // destructed it will reacquire the HOM lock. Since it releases the HOM lock,
1259 // it's important that a HOM_AutoLock was already created in a containing
1260 // scope.
1261 //
1262 // Use HOM_AutoUnlock in conjunction with PY_InterpreterAutoUnlock to
1263 // also release the Python GIL. Be sure to create the HOM_AutoUnlock *after*
1264 // the PY_InterpreterAutoUnlock, so that when the auto locks are destructed
1265 // the HOM lock is reacquired before the Python GIL. Otherwise, it will grab
1266 // the GIL and then try to grab the HOM lock, and if another thread with the
1267 // HOM lock tries to run Python we'll end up with deadlock.
1269 {
1270 public:
1272  {
1273  if (HOMgetLock().hasLock())
1274  {
1275  HOMgetLock().unlock();
1276  myUnlocked = true;
1277  }
1278  else
1279  {
1280  myUnlocked = false;
1281  }
1282  }
1283 
1285  {
1286  if (myUnlocked)
1287  HOMgetLock().lock();
1288  }
1289 
1290 private:
1291  bool myUnlocked;
1292 };
1293 
1294 
1295 // These macros are used to help detect memory leaks when debugging is enabled.
1296 #ifdef HOM_DEBUG
1297 #define HOM_CONSTRUCT_OBJECT(pointer) \
1298  HOM().constructObject(pointer, typeid(*pointer));
1299 #define HOM_DESTRUCT_OBJECT(pointer) \
1300  HOM().destructObject(pointer, typeid(*pointer));
1301 #else
1302 #define HOM_CONSTRUCT_OBJECT(pointer)
1303 #define HOM_DESTRUCT_OBJECT(pointer)
1304 #endif
1305 
1306 // NOTE: These typedefs cannot actually be used in any method declaration
1307 // that SWIG needs to generate code for because it doesn't understand
1308 // them.
1309 // gcc gets a parse error if we try to give a default map value in the
1310 // signature, and the typedef avoids the error.
1311 typedef std::map<std::string, std::string> HOM_StdMapStringString;
1312 typedef std::map<HOM_EnumValue *, std::string> HOM_StdMapEnumString;
1313 
1314 
1315 // Houdini will call HOMextendLibrary() in HDK dso's so the user can install
1316 // C++ HOM extensions.
1317 extern "C" {
1319 }
1320 
1321 #endif //__HOM_Module_h__
std::string ignore_case(std::string item)
Helper function to allow ignore_case to be passed to IsMember or Transform.
Definition: CLI11.h:3456
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2545
GLdouble GLdouble GLint GLint const GLdouble * points
Definition: glad.h:2676
#define SYS_VISIBILITY_EXPORT
void
Definition: png.h:1083
UT_TaskRootLock & HOMgetLock()
Definition: HOM_Module.h:1195
GT_API const UT_StringHolder time
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
const GLuint GLenum const void * binary
Definition: glcorearb.h:1924
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
UT_UniquePtr< T > HOMdel(T *hom_object)
Definition: HOM_Module.h:1177
Definition: HOM_ik.h:21
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
ImageBuf OIIO_API min(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Quat< T > spline(const Quat< T > &q0, const Quat< T > &q1, const Quat< T > &q2, const Quat< T > &q3, T t) IMATH_NOEXCEPT
Definition: ImathQuat.h:576
GLint y
Definition: glcorearb.h:103
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glcorearb.h:2539
std::string help(const App *app, const Error &e)
Printout the full help string on error (if this fn is set, the old default for CLI11) ...
Definition: CLI11.h:8978
GLenum const GLfloat * params
Definition: glcorearb.h:105
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
Definition: HOM_qt.h:20
GLint GLsizei GLsizei height
Definition: glcorearb.h:103
UT_TaskLockT< false > UT_TaskRootLock
Definition: UT_TaskLock.h:289
HOM_API UT_TaskRootLock * HOM_theHOMLock
bool any(const vbool4 &v)
Definition: simd.h:3468
#define HOM_API
Definition: HOM_API.h:13
void ignore(T const &) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6508
virtual ~HOM_Module()
Definition: HOM_Module.h:184
constexpr std::enable_if< I< type_count_base< T >::value, int >::type tuple_type_size(){return subtype_count< typename std::tuple_element< I, T >::type >::value+tuple_type_size< T, I+1 >);}template< typename T > struct type_count< T, typename std::enable_if< is_tuple_like< T >::value >::type >{static constexpr int value{tuple_type_size< T, 0 >)};};template< typename T > struct subtype_count{static constexpr int value{is_mutable_container< T >::value?expected_max_vector_size:type_count< T >::value};};template< typename T, typename Enable=void > struct type_count_min{static const int value{0};};template< typename T >struct type_count_min< T, typename std::enable_if<!is_mutable_container< T >::value &&!is_tuple_like< T >::value &&!is_wrapper< T >::value &&!is_complex< T >::value &&!std::is_void< T >::value >::type >{static constexpr int value{type_count< T >::value};};template< typename T > struct type_count_min< T, typename std::enable_if< is_complex< T >::value >::type >{static constexpr int value{1};};template< typename T >struct type_count_min< T, typename std::enable_if< is_wrapper< T >::value &&!is_complex< T >::value &&!is_tuple_like< T >::value >::type >{static constexpr int value{subtype_count_min< typename T::value_type >::value};};template< typename T, std::size_t I >constexpr typename std::enable_if< I==type_count_base< T >::value, int >::type tuple_type_size_min(){return 0;}template< typename T, std::size_t I > constexpr typename std::enable_if< I< type_count_base< T >::value, int >::type tuple_type_size_min(){return subtype_count_min< typename std::tuple_element< I, T >::type >::value+tuple_type_size_min< T, I+1 >);}template< typename T > struct type_count_min< T, typename std::enable_if< is_tuple_like< T >::value >::type >{static constexpr int value{tuple_type_size_min< T, 0 >)};};template< typename T > struct subtype_count_min{static constexpr int value{is_mutable_container< T >::value?((type_count< T >::value< expected_max_vector_size)?type_count< T >::value:0):type_count_min< T >::value};};template< typename T, typename Enable=void > struct expected_count{static const int value{0};};template< typename T >struct expected_count< T, typename std::enable_if<!is_mutable_container< T >::value &&!is_wrapper< T >::value &&!std::is_void< T >::value >::type >{static constexpr int value{1};};template< typename T > struct expected_count< T, typename std::enable_if< is_mutable_container< T >::value >::type >{static constexpr int value{expected_max_vector_size};};template< typename T >struct expected_count< T, typename std::enable_if<!is_mutable_container< T >::value &&is_wrapper< T >::value >::type >{static constexpr int value{expected_count< typename T::value_type >::value};};enum class object_category:int{char_value=1, integral_value=2, unsigned_integral=4, enumeration=6, boolean_value=8, floating_point=10, number_constructible=12, double_constructible=14, integer_constructible=16, string_assignable=23, string_constructible=24, other=45, wrapper_value=50, complex_number=60, tuple_value=70, container_value=80,};template< typename T, typename Enable=void > struct classify_object{static constexpr object_category value{object_category::other};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_integral< T >::value &&!std::is_same< T, char >::value &&std::is_signed< T >::value &&!is_bool< T >::value &&!std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::integral_value};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_integral< T >::value &&std::is_unsigned< T >::value &&!std::is_same< T, char >::value &&!is_bool< T >::value >::type >{static constexpr object_category value{object_category::unsigned_integral};};template< typename T >struct classify_object< T, typename std::enable_if< std::is_same< T, char >::value &&!std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::char_value};};template< typename T > struct classify_object< T, typename std::enable_if< is_bool< T >::value >::type >{static constexpr object_category value{object_category::boolean_value};};template< typename T > struct classify_object< T, typename std::enable_if< std::is_floating_point< T >::value >::type >{static constexpr object_category value{object_category::floating_point};};template< typename T >struct classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&std::is_assignable< T &, std::string >::value >::type >{static constexpr object_category value{object_category::string_assignable};};template< typename T >struct classify_object< T, typename std::enable_if<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&!std::is_assignable< T &, std::string >::value &&(type_count< T >::value==1)&&std::is_constructible< T, std::string >::value >::type >{static constexpr object_category value{object_category::string_constructible};};template< typename T > struct classify_object< T, typename std::enable_if< std::is_enum< T >::value >::type >{static constexpr object_category value{object_category::enumeration};};template< typename T > struct classify_object< T, typename std::enable_if< is_complex< T >::value >::type >{static constexpr object_category value{object_category::complex_number};};template< typename T > struct uncommon_type{using type=typename std::conditional<!std::is_floating_point< T >::value &&!std::is_integral< T >::value &&!std::is_assignable< T &, std::string >::value &&!std::is_constructible< T, std::string >::value &&!is_complex< T >::value &&!is_mutable_container< T >::value &&!std::is_enum< T >::value, std::true_type, std::false_type >::type;static constexpr bool value=type::value;};template< typename T >struct classify_object< T, typename std::enable_if<(!is_mutable_container< T >::value &&is_wrapper< T >::value &&!is_tuple_like< T >::value &&uncommon_type< T >::value)>::type >{static constexpr object_category value{object_category::wrapper_value};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::number_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&!is_direct_constructible< T, double >::value &&is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::integer_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< uncommon_type< T >::value &&type_count< T >::value==1 &&!is_wrapper< T >::value &&is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value >::type >{static constexpr object_category value{object_category::double_constructible};};template< typename T >struct classify_object< T, typename std::enable_if< is_tuple_like< T >::value &&((type_count< T >::value >=2 &&!is_wrapper< T >::value)||(uncommon_type< T >::value &&!is_direct_constructible< T, double >::value &&!is_direct_constructible< T, int >::value)||(uncommon_type< T >::value &&type_count< T >::value >=2))>::type >{static constexpr object_category value{object_category::tuple_value};};template< typename T > struct classify_object< T, typename std::enable_if< is_mutable_container< T >::value >::type >{static constexpr object_category value{object_category::container_value};};template< typename T, enable_if_t< classify_object< T >::value==object_category::char_value, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"CHAR";}template< typename T, enable_if_t< classify_object< T >::value==object_category::integral_value||classify_object< T >::value==object_category::integer_constructible, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"INT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::unsigned_integral, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"UINT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::floating_point||classify_object< T >::value==object_category::number_constructible||classify_object< T >::value==object_category::double_constructible, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"FLOAT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::enumeration, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"ENUM";}template< typename T, enable_if_t< classify_object< T >::value==object_category::boolean_value, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"BOOLEAN";}template< typename T, enable_if_t< classify_object< T >::value==object_category::complex_number, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"COMPLEX";}template< typename T, enable_if_t< classify_object< T >::value >=object_category::string_assignable &&classify_object< T >::value<=object_category::other, detail::enabler >=detail::dummy >constexpr const char *type_name(){return"TEXT";}template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value >=2, detail::enabler >=detail::dummy >std::string type_name();template< typename T, enable_if_t< classify_object< T >::value==object_category::container_value||classify_object< T >::value==object_category::wrapper_value, detail::enabler >=detail::dummy >std::string type_name();template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value==1, detail::enabler >=detail::dummy >inline std::string type_name(){return type_name< typename std::decay< typename std::tuple_element< 0, T >::type >::type >);}template< typename T, std::size_t I >inline typename std::enable_if< I==type_count_base< T >::value, std::string >::type tuple_name(){return std::string{};}template< typename T, std::size_t I >inline typename std::enable_if<(I< type_count_base< T >::value), std::string >::type tuple_name(){auto str=std::string{type_name< typename std::decay< typename std::tuple_element< I, T >::type >::type >)}+ ','+tuple_name< T, I+1 >);if(str.back()== ',') str.pop_back();return str;}template< typename T, enable_if_t< classify_object< T >::value==object_category::tuple_value &&type_count_base< T >::value >=2, detail::enabler > > std::string type_name()
Recursively generate the tuple type name.
Definition: CLI11.h:1729
GLsizei GLsizei GLchar * source
Definition: glcorearb.h:803
Definition: HOM_ui.h:46
long long int64
Definition: SYS_Types.h:116
GLfloat GLfloat GLfloat alpha
Definition: glcorearb.h:112
GLuint const GLchar * name
Definition: glcorearb.h:786
GLushort pattern
Definition: glad.h:2583
GA_API const UT_StringHolder transform
GLint GLenum GLint x
Definition: glcorearb.h:409
Attempt to access an object that no longer exists in Houdini Invalid output Invalid type The attempted operation failed Node initialization script failed Failed to modify node or parameter because of a permission error Possible causes include locked takes
Definition: HOM_Errors.h:191
GLenum mode
Definition: glcorearb.h:99
GLfloat units
Definition: glcorearb.h:408
GLenum GLint GLint * precision
Definition: glcorearb.h:1925
std::map< HOM_EnumValue *, std::string > HOM_StdMapEnumString
Definition: HOM_Module.h:1312
std::string OIIO_UTIL_API repeat(string_view str, int n)
Repeat a string formed by concatenating str n times.
OIIO_API string_view getenv(string_view name, string_view defaultval)
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2002
SYS_VISIBILITY_EXPORT void HOMextendLibrary()
GLenum void ** pointer
Definition: glcorearb.h:810
GLuint color
Definition: glcorearb.h:1261
fpreal64 fpreal
Definition: SYS_Types.h:277
GLuint index
Definition: glcorearb.h:786
GLuint GLfloat * val
Definition: glcorearb.h:1608
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
virtual bool readFile(GA_Detail &g, const char *filename, const GA_LoadOptions *opts, UT_StringArray *errors) const
Class which defines an I/O interface to save/load geometry.
GLint GLsizei width
Definition: glcorearb.h:103
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:857
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
SYS_VISIBILITY_EXPORT void newHandle(BM_ResourceManager *m)
Definition: core.h:1131
void unlock()
Definition: UT_TaskLock.h:261
HOM_API HOM_Module & HOM()
type
Definition: core.h:1059
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T clip(const T &p, const Box< T > &box) IMATH_NOEXCEPT
Definition: ImathBoxAlgo.h:29
static bool isImplementationSet()
Definition: HOM_Module.h:547
std::map< std::string, std::string > HOM_StdMapStringString
Definition: HOM_Module.h:1311
UT_UniquePtr< UT_OptionEntry > UT_OptionEntryPtr
Definition: format.h:895
ImageBuf OIIO_API channels(const ImageBuf &src, int nchannels, cspan< int > channelorder, cspan< float > channelvalues={}, cspan< std::string > newchannelnames={}, bool shuffle_channel_names=false, int nthreads=0)