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. This way, the methods of this class appear as the
10  * top-level parts of the hou module.
11  */
12 
13 #ifndef __HOM_Module_h__
14 #define __HOM_Module_h__
15 
16 #include "HOM_API.h"
17 #include "HOM_BinaryString.h"
18 #include "HOM_Defines.h"
19 #include "HOM_Errors.h"
20 #include "HOM_ElemPtr.h"
21 #include "HOM_EnumModules.h"
23 #include <UT/UT_Lock.h>
24 #include <UT/UT_NonCopyable.h>
25 #include <UT/UT_Notifier.h>
26 #include <UT/UT_TaskLock.h>
27 #include <UT/UT_Thread.h>
28 #include <UT/UT_UniquePtr.h>
29 #include <SYS/SYS_Types.h>
30 #include <typeinfo>
31 #include <string>
32 #include <vector>
33 #include <map>
34 #include <hboost/any.hpp>
35 
36 class UT_OptionEntry;
37 class OP_Node;
38 class STORUI_OrboltURLHandler;
39 class HOM_AgentClip;
41 class HOM_AgentLayer;
42 class HOM_AgentRig;
43 class HOM_AgentShape;
48 class HOM_anonstats;
49 class HOM_audio;
51 class HOM_ChopNode;
52 class HOM_Color;
53 class HOM_crowds;
55 class HOM_Drawable;
56 class HOM_dop;
57 class HOM_Edge;
58 class HOM_EnumValue;
59 class HOM_EvaluationCache;
63 class HOM_galleries;
64 class HOM_Geometry;
66 class HOM_hda;
67 class HOM_HDADefinition;
68 class HOM_HDAModule;
69 class HOM_HDAOptions;
70 class HOM_hipFile;
71 class HOM_hmath;
74 class HOM_Keyframe;
78 class HOM_NetworkBox;
79 class HOM_NetworkDot;
81 class HOM_Node;
82 class HOM_NodeBundle;
83 class HOM_NodeConnection;
84 class HOM_NodeType;
87 class HOM_Parm;
88 class HOM_ParmTemplate;
90 class HOM_ParmTuple;
91 class HOM_perfMon;
93 class HOM_pypanel;
94 class HOM_playbar;
95 class HOM_Point;
96 class HOM_Prim;
97 class HOM_properties;
98 class HOM_qt;
100 class HOM_RedrawBlock;
101 #ifndef SWIG
103 #endif
104 class HOM_SceneViewer;
106 class HOM_Selection;
108 class HOM_shelves;
109 class HOM_StickyNote;
110 class HOM_StringKeyframe;
113 class HOM_styles;
114 class HOM_StyleSheet;
115 class HOM_takes;
117 class HOM_ui;
118 class HOM_hotkeys;
119 class HOM_UIEvent;
120 class HOM_UIEventDevice;
121 class HOM_undos;
122 class HOM_Vertex;
123 class HOM_VexContext;
124 class HOM_ViewerEvent;
126 class HOM_ViewerStateMenu;
128 
129 #define HOM_SESSION_MODULE_NAME "hou.session"
130 #define HOM_SESSION_MODULE_CPIO_NAME "." HOM_SESSION_MODULE_NAME
131 
132 // Use this function to access the HOM module from C++ in Houdini. This
133 // is equivalent to writing "hou" in python. It will only throw an exception
134 // if the python module could not be imported, which should not happen.
135 class HOM_Module;
137 
139 {
140 public:
141  static void setHOMCreator(void (*homCreator)());
142 
143  virtual ~HOM_Module() {}
144 
145  virtual std::vector<std::string> _getArgumentAutoComplete(
146  const char *method_name, const char *arguments,
147  bool meta_info_only = false) = 0;
148 
149  // This method is called by the expression editor to force autocompletion
150  // to be relative to the node containing the expression. It is not
151  // wrapped by swig.
152  virtual void setRelativeNodeForAutoComplete(OP_Node *node) = 0;
153 
154  virtual HOM_ui& ui() = 0;
155  virtual HOM_qt& qt() = 0;
156  virtual HOM_hotkeys& hotkeys() = 0;
157  virtual HOM_audio& audio() = 0;
158  virtual bool isUIAvailable() = 0;
159  virtual bool _isCurrentThreadHoldingHOMLock() = 0;
160 
161  virtual HOM_galleries& galleries() = 0;
162  virtual HOM_hda& hda() = 0;
163  virtual HOM_hipFile& hipFile() = 0;
164  virtual HOM_perfMon& perfMon() = 0;
165  virtual HOM_playbar& playbar() = 0;
166  virtual HOM_pypanel& pypanel() = 0;
167  virtual HOM_hmath& hmath() = 0;
168  virtual HOM_dop& dop() = 0;
169  virtual HOM_properties& properties() = 0;
170  virtual HOM_shelves& shelves() = 0;
171  virtual HOM_styles& styles() = 0;
172  virtual HOM_takes& takes() = 0;
173  virtual HOM_undos& undos() = 0;
174  virtual HOM_viewportVisualizers& viewportVisualizers() = 0;
175  virtual HOM_anonstats& anonstats() = 0;
176  virtual HOM_crowds& crowds() = 0;
177 
178  virtual void exit(int exit_code=0, bool suppress_save_prompt=false) = 0;
179 
180  // isExiting() will return true if the program is actually Houdini (not
181  // mplay) and the UI queue is closed. This method is wrapped by swig, but
182  // only so houdiniInterpreter can call it.
183  virtual bool isExiting() = 0;
184 
185  virtual void addPreloadIcon(const char *name, int w, int h) = 0;
186  virtual void rasterizePreloadIcons() = 0;
187 
188  virtual std::string applicationName() = 0;
189  virtual std::vector<int> applicationVersion(bool include_patch=false) = 0;
190  virtual std::string applicationVersionString() = 0;
191  virtual std::string applicationCompilationDate() = 0;
192  virtual std::string applicationPlatformInfo() = 0;
193  virtual HOM_EnumValue &licenseCategory() = 0;
194  virtual bool isApprentice() = 0;
195  virtual void releaseLicense() = 0;
196 
197  // Threading controls
198  virtual int maxThreads() = 0;
199  virtual void setMaxThreads(int max_threads) = 0;
200 
201  // These methods return a new HOM_Node object.
202  virtual HOM_Node* root() = 0;
203  virtual HOM_Node* pwd() = 0;
204  virtual HOM_Node* parent() = 0;
205 
206  virtual void setPwd(HOM_Node &newpwd) = 0;
207  virtual void cd(const char *path) = 0;
208 
209  // Calling phm() is a shortcut for calling pwd().hdaModule().
210  virtual HOM_HDAModule* phm() = 0;
211 
212  // This method returns a new HOM_DopNetNode object or None.
213  virtual HOM_Node* currentDopNet() = 0;
214  virtual void setCurrentDopNet(HOM_Node &dopnet) = 0;
215 
216  // Gets or sets the simulation enabled state.
217  virtual bool simulationEnabled() = 0;
218  virtual void setSimulationEnabled(bool enabled) = 0;
219 
220  // These methods return a new HOM_Node object or null if the node couldn't
221  // be found.
222  virtual HOM_Node *node(const char *path) = 0;
223  virtual HOM_NetworkMovableItem* item(const char *path) = 0;
224 
225  virtual std::vector<HOM_ElemPtr<HOM_Node> > nodes(const std::vector<std::string> &paths) = 0;
226  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > items(const std::vector<std::string> &paths) = 0;
227 
228  virtual HOM_Node *nodeBySessionId(int session_id) = 0;
229  virtual HOM_NetworkBox *networkBoxBySessionId(int session_id) = 0;
230  virtual HOM_StickyNote *stickyNoteBySessionId(int session_id) = 0;
231  virtual HOM_SubnetIndirectInput *subnetIndirectInputBySessionId(
232  int64 session_id) = 0;
233  virtual HOM_NetworkDot *networkDotBySessionId(int session_id) = 0;
234  virtual HOM_NetworkMovableItem *itemBySessionId(
235  HOM_EnumValue &item_type, int64 session_id) = 0;
236  virtual HOM_NodeConnection *nodeConnectionBySessionId(
237  int node_session_id, int input_index) = 0;
238 
239  // Functions for configuring default colors on network elements.
240  virtual HOM_Color defaultColor(HOM_EnumValue &color_item) = 0;
241  virtual void setDefaultColor(HOM_EnumValue &color_item, HOM_Color *color) = 0;
242 
243  // Return HOM_Nodes for all selected nodes in the session.
244  virtual std::vector<HOM_ElemPtr<HOM_Node> > selectedNodes(
245  bool include_hidden = false) = 0;
246  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > selectedItems(
247  bool include_hidden = false) = 0;
248  virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> > selectedConnections() = 0;
249  virtual void clearAllSelected() = 0;
250 
251  // Copy nodes to and paste from clipboard.
252  virtual void copyNodesToClipboard(const std::vector<HOM_Node *> &nodes) = 0;
253  virtual void pasteNodesFromClipboard(HOM_Node &destination_node) = 0;
254 
255  // These methods return new HOM_Parm/HOM_ParmTuple objects or null if the
256  // parm couldn't be found.
257  virtual HOM_Parm* parm(const char *path) = 0;
258  virtual HOM_ParmTuple* parmTuple(const char *path) = 0;
259  virtual HOM_Parm *evaluatingParm() = 0;
260 
261  virtual HOM_ScriptEvalContext * newScriptEvalContext(HOM_Node &node) = 0;
262  virtual HOM_ScriptEvalContext * newScriptEvalContext(HOM_Parm &parm) = 0;
263 
264  // Access to the contents of the parm clipboard
265  virtual std::vector< std::map<std::string, std::string> >
266  parmClipboardContents() = 0;
267 
268  // These methods return a new HOM_NodeType object or null if it couldn't
269  // be found.
270  virtual HOM_NodeType *nodeType(
271  HOM_NodeTypeCategory &category, const char *name) = 0;
272  virtual HOM_NodeType *nodeType(const char *name) = 0;
273 
274  virtual HOM_NodeType *preferredNodeType(
275  const char *name, HOM_Node *parentNode = NULL) = 0;
276 
277  virtual HOM_NodeTypeCategory &objNodeTypeCategory() = 0;
278  virtual HOM_NodeTypeCategory &sopNodeTypeCategory() = 0;
279  virtual HOM_NodeTypeCategory &popNodeTypeCategory() = 0;
280  virtual HOM_NodeTypeCategory &dopNodeTypeCategory() = 0;
281  virtual HOM_NodeTypeCategory &cop2NodeTypeCategory() = 0;
282  virtual HOM_NodeTypeCategory &shopNodeTypeCategory() = 0;
283  virtual HOM_NodeTypeCategory &vopNodeTypeCategory() = 0;
284  virtual HOM_NodeTypeCategory &ropNodeTypeCategory() = 0;
285  virtual HOM_NodeTypeCategory &chopNodeTypeCategory() = 0;
286  virtual HOM_NodeTypeCategory &topNodeTypeCategory() = 0;
287  virtual HOM_NodeTypeCategory &lopNodeTypeCategory() = 0;
288  virtual HOM_NodeTypeCategory &popNetNodeTypeCategory() = 0;
289  virtual HOM_NodeTypeCategory &cop2NetNodeTypeCategory() = 0;
290  virtual HOM_NodeTypeCategory &vopNetNodeTypeCategory() = 0;
291  virtual HOM_NodeTypeCategory &chopNetNodeTypeCategory() = 0;
292  virtual HOM_NodeTypeCategory &managerNodeTypeCategory() = 0;
293  virtual HOM_NodeTypeCategory &rootNodeTypeCategory() = 0;
294  virtual std::map<std::string, HOM_NodeTypeCategory *>
295  nodeTypeCategories() = 0;
296 
297  virtual std::vector<HOM_ElemPtr<HOM_Node> > copyNodesTo(
298  const std::vector<HOM_Node *> &nodes,
299  HOM_Node &destination_node) = 0;
300  virtual std::vector<HOM_ElemPtr<HOM_Node> > moveNodesTo(
301  const std::vector<HOM_Node *> &nodes,
302  HOM_Node &destination_node) = 0;
303 
304  virtual HOM_NodeBundle *addNodeBundle(const char *name = NULL) = 0;
305  virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > nodeBundles() = 0;
306  virtual std::vector<HOM_ElemPtr<HOM_NodeBundle> > selectedNodeBundles() = 0;
307  virtual HOM_NodeBundle *nodeBundle(const char *name) = 0;
308 
309  virtual HOM_HDADefinition *hdaDefinition(
310  HOM_NodeTypeCategory &category, const char *name,
311  const char *file_path) = 0;
312 
313  // Note that getTimeWithoutAddingDependency is not wrapped by swig.
314  virtual fpreal getTimeWithoutAddingDependency() = 0;
315  virtual double time() = 0;
316  virtual void setTime(double time) = 0;
317  virtual double frame() = 0;
318  virtual int intFrame() = 0;
319  virtual void setFrame(double frame) = 0;
320  virtual double fps() = 0;
321  virtual void setFps(double fps) = 0;
322  virtual double timeToFrame(double time) = 0;
323  virtual double frameToTime(double frame) = 0;
324 
325  // Computes a scale factor given units
326  virtual fpreal scaleFromMKS(const char *units) = 0;
327  virtual fpreal scaleToMKS(const char *units) = 0;
328 
329  virtual double bezier() = 0;
330  virtual double constant() = 0;
331  virtual double cubic() = 0;
332  virtual double cycle(double start_frame, double end_frame) = 0;
333  virtual double cyclet(double start_time, double end_time) = 0;
334  virtual double cycleoffset(double start_frame, double end_frame) = 0;
335  virtual double cycleoffsett(double start_time, double end_time) = 0;
336  virtual double ease() = 0;
337  virtual double easein() = 0;
338  virtual double easeinp(double ease_speed) = 0;
339  virtual double easeout() = 0;
340  virtual double easeoutp(double ease_speed) = 0;
341  virtual double easep(double ease_bias) = 0;
342  virtual double linear() = 0;
343  virtual double match() = 0;
344  virtual double matchin() = 0;
345  virtual double matchout() = 0;
346  virtual double qlinear() = 0;
347  virtual double quintic() = 0;
348  virtual double repeat(double start_frame, double end_frame) = 0;
349  virtual double repeatt(double start_time, double end_time) = 0;
350  virtual double spline() = 0;
351  virtual double vmatch() = 0;
352  virtual double vmatchin() = 0;
353  virtual double vmatchout() = 0;
354 
355  virtual std::string chopExportConflictResolutionPattern() = 0;
356  virtual void setChopExportConflictResolutionPattern( const char *pattern) = 0;
357 
358  virtual std::vector<HOM_ElemPtr<HOM_VexContext> >
359  vexContexts() = 0;
360 
361  virtual HOM_VexContext* vexContextForShaderType(HOM_EnumValue &shader_type) = 0;
362 
363  virtual HOM_VexContext* vexContextForNodeTypeCategory(
364  HOM_NodeTypeCategory &node_type_category) = 0;
365 
366  virtual std::string helpServerUrl() = 0;
367 
368  virtual std::string hscriptCommandHelp(const char *command_name) = 0;
369 
370  // This method returns a pair of strings: one for stdout and one for
371  // stderr.
372  virtual std::vector<std::string> hscript(const char *command) = 0;
373 
374  // Compare if two numbers are almost equal.
375  virtual bool almostEqual(double x, double y) = 0;
376 
377  virtual std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> >
378  fileReferences(
379  const char *project_dir_variable="HIP", bool include_all_refs=true) = 0;
380 
381  // Find files in $HOUDINI_PATH.
382  virtual std::string findFile(const char *file_name) = 0;
383  virtual std::vector<std::string> findFiles(
384  const char *file_name) = 0;
385  virtual std::vector<std::string> findFilesWithExtension(
386  const char *file_extension, const char *subdirectory = NULL) = 0;
387 
388  // Find directories in $HOUDINI_PATH.
389  virtual std::string findDirectory(const char *directory_name) = 0;
390  virtual std::vector<std::string> findDirectories(
391  const char *directory_name) = 0;
392 
393  virtual std::vector<std::string> houdiniPath(const char *pathvar = nullptr) = 0;
394 
395  virtual std::string homeHoudiniDirectory() = 0;
396 
397  virtual HOM_BinaryString readFile(const char *file_path) = 0;
398 
399  virtual std::map<std::string, HOM_BinaryString> loadIndexDataFromString(
400  const char *data, int length) = 0;
401 
402  virtual std::map<std::string, HOM_BinaryString> loadIndexDataFromFile(
403  const char *file_path) = 0;
404 
405  virtual HOM_BinaryString saveIndexDataToString(
406  const std::map<std::string, std::string> &index_data) = 0;
407 
408  virtual void saveIndexDataToFile(
409  const char *file_path,
410  const std::map<std::string, std::string> &index_data) = 0;
411 
412  // Note that, when wrapped by swig, this function takes a single string
413  // parameter.
414  virtual std::vector<std::pair<std::string, HOM_BinaryString> >
415  loadCPIODataFromString(const char *data, int length) = 0;
416 
417  virtual HOM_BinaryString saveCPIODataToString(
418  const std::vector<std::pair<std::string, std::string> > &data) = 0;
419 
420  // These 3 methods are not wrapped by swig. They are used to notify
421  // interested parties that a change to the module source code was made and
422  // that they should forcefully update to match the change. The third
423  // is used to load the session module source from a hip file, even though
424  // that source might generate an exception.
425  virtual UT_NotifierImpl<int> &getSessionModuleSourceForceUpdateNotifier()=0;
426  virtual void forceUpdateFromSessionModuleSource() = 0;
427  virtual void forceSetSessionModuleSource(const char *source) = 0;
428 
429  virtual void setSessionModuleSource(const char *source) = 0;
430  virtual void appendSessionModuleSource(const char *source) = 0;
431  virtual std::string sessionModuleSource() = 0;
432  // This method is not wrapped by swig:
433  virtual int sessionModuleSourceChangeCount() = 0;
434 
435  // This static method lets you know if the HOM implementation is set,
436  // so you can check if it's safe to call the HOM() function. This method
437  // should only be called in rare cases.
438  static bool isImplementationSet()
439  { return theImplementation != NULL; }
440 
441  // Evaluates a parameter as if it was an OPpath parameter
442  virtual std::string chsop(const char *path) = 0;
443 
444  // Evaluates a parameter as if it was an OPlist parameter
445  virtual std::string chsoplist(const char *path) = 0;
446 
447  // Sorts a list of node paths using topological order from the graph.
448  virtual std::vector<std::string>
449  sortedNodePaths(const std::vector<std::string> &paths) = 0;
450 
451  // Sorts a list of HOM_Node using topological order from the graph.
452  virtual std::vector<HOM_ElemPtr<HOM_Node> >
453  sortedNodes(const std::vector<HOM_Node*> &nodes) = 0;
454 
455  virtual int patternMatch(
456  const char *pattern, const char *str,
457  bool ignore_case = false,
458  bool path_match = false) = 0;
459 
460  // hscriptExpression() will return different types, according to
461  // the return value of the expression.
462  virtual hboost::any hscriptExpression(const char *expression) = 0;
463  virtual double hscriptFloatExpression(const char *expression) = 0;
464  virtual std::string hscriptStringExpression(const char *expression) = 0;
465  virtual std::vector<double>hscriptVectorExpression(
466  const char *expression) = 0;
467  virtual std::vector<std::vector<double> > hscriptMatrixExpression(
468  const char *expression) = 0;
469 
470  virtual std::string expandString(const char *str) = 0;
471  virtual std::string expandStringAtFrame(const char *str, double frame) = 0;
472 
473  virtual double lvar(const char *name) = 0;
474 
475  virtual char *getenv(const char *name, const char *default_value=NULL) = 0;
476 
477  virtual void putenv(const char *name, const char *value) = 0;
478 
479  virtual void unsetenv(const char *name) = 0;
480 
481  virtual void allowEnvironmentToOverwriteVariable(
482  const char *name, bool onoff) = 0;
483 
484  virtual void *expressionGlobals() = 0;
485 
486  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
487 
488  // This method is used to interact with the global interrupt object.
489  virtual bool updateProgressAndCheckForInterrupt(int percentage=-1) = 0;
490 
491  virtual std::map<std::string, hboost::any> runVex(
492  const char *vex_file,
493  const std::map<std::string, hboost::any> &inputs,
494  const char *precision = "32") = 0;
495 
496  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
497 
498  virtual void saveImageDataToFile(
499  const std::vector<float> &color_and_alpha_data,
500  int width, int height,
501  const char *file_name) = 0;
502 
503  virtual void saveImageDataToFile(
504  const std::string &color_and_alpha_data,
505  int width, int height,
506  const char *file_name) = 0;
507 
508  virtual HOM_BinaryString loadImageDataFromFile(
509  const char *image_file_name,
510  HOM_EnumValue &image_depth = HOM_imageDepth::Int8) = 0;
511 
512  virtual std::vector<int> imageResolution(const char *image_file_name) = 0;
513 
514  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
515 
516  virtual HOM_EnumValue &updateModeSetting() = 0;
517  virtual void setUpdateMode(HOM_EnumValue &mode) = 0;
518 
519  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
520 
521  virtual HOM_OrboltURLHandler *orboltURLHandler() = 0;
522 
523  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
524 
525  virtual void *opaqueRunCallbackAndCatchCrashes(void *opaque_callback) = 0;
526 
527  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
528 
529  // These methods are used to grant functions defined in an asset's
530  // PythonModule enhanced privileges. They are not wrapped by swig.
531  virtual void pushAccessPrivilege(const char *key) = 0;
532  virtual void popAccessPrivilege(const char *key) = 0;
533 
534  virtual std::string currentPythonModuleKey() = 0;
535 
536  virtual void registerAccessPrivilegePyClient(void *opaque_python_object) = 0;
537 
538  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
539 
540  // These methods are used to instantiate HOMF objects from the HOM
541  // library level. They are not wrapped by swig.
542  virtual HOM_FloatParmTemplate *newFloatParmTemplate(
543  const char *name,
544  const char *label,
545  int num_components,
546  const std::vector<double> &default_value,
547  double min, double max,
548  bool min_is_strict, bool max_is_strict,
549  HOM_EnumValue &look,
550  HOM_EnumValue &naming_scheme,
551  const char *disable_when,
552  bool is_hidden,
553  bool is_label_hidden,
554  bool join_with_next,
555  const char *help,
556  const char *script_callback,
557  HOM_EnumValue &script_callback_language,
558  const std::map<std::string, std::string> &tags,
559  const std::map<HOM_EnumValue, std::string> &conditionals,
560  const std::vector<std::string> &default_expression,
561  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
562 
563  virtual HOM_IntParmTemplate *newIntParmTemplate(
564  const char *name,
565  const char *label,
566  int num_components,
567  const std::vector<int> &default_value,
568  int min, int max,
569  bool min_is_strict, bool max_is_strict,
570  HOM_EnumValue &naming_scheme,
571  const std::vector<std::string> &menu_items,
572  const std::vector<std::string> &menu_labels,
573  const std::vector<std::string> &icon_names,
574  const std::string &item_generator_script,
575  HOM_EnumValue *item_generator_script_language,
576  HOM_EnumValue &menu_type,
577  bool menu_use_token,
578  const char *disable_when,
579  bool is_hidden,
580  bool is_label_hidden,
581  bool join_with_next,
582  const char *help,
583  const char *script_callback,
584  HOM_EnumValue &script_callback_language,
585  const std::map<std::string, std::string> &tags,
586  const std::map<HOM_EnumValue, std::string> &conditionals,
587  const std::vector<std::string> &default_expression,
588  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
589 
590  virtual HOM_StringParmTemplate *newStringParmTemplate(
591  const char *name,
592  const char *label,
593  int num_components,
594  const std::vector<std::string> &default_value,
595  HOM_EnumValue &naming_scheme,
596  HOM_EnumValue &string_type,
597  HOM_EnumValue &file_type,
598  const std::vector<std::string> &menu_items,
599  const std::vector<std::string> &menu_labels,
600  const std::vector<std::string> &icon_names,
601  const std::string &item_generator_script,
602  HOM_EnumValue *item_generator_script_language,
603  HOM_EnumValue &menu_type,
604  const char *disable_when,
605  bool is_hidden,
606  bool is_label_hidden,
607  bool join_with_next,
608  const char *help,
609  const char *script_callback,
610  HOM_EnumValue &script_callback_language,
611  const std::map<std::string, std::string> &tags,
612  const std::map<HOM_EnumValue, std::string> &conditionals,
613  const std::vector<std::string> &default_expression,
614  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
615 
616  virtual HOM_DataParmTemplate *newDataParmTemplate(
617  const char *name,
618  const char *label,
619  int num_components,
620  HOM_EnumValue &look,
621  HOM_EnumValue &naming_scheme,
622  HOM_EnumValue &data_parm_type,
623  const char *disable_when,
624  bool is_hidden,
625  bool is_label_hidden,
626  bool join_with_next,
627  const char *help,
628  const char *script_callback,
629  HOM_EnumValue &script_callback_language,
630  const std::map<std::string, std::string> &tags,
631  const std::map<HOM_EnumValue, std::string> &conditionals,
632  const std::vector<std::string> &default_expression,
633  const std::vector<HOM_EnumValue *> &default_expression_language) = 0;
634 
635  virtual HOM_ToggleParmTemplate *newToggleParmTemplate(
636  const char *name,
637  const char *label,
638  bool default_value,
639  const char *disable_when,
640  bool is_hidden,
641  bool is_label_hidden,
642  bool join_with_next,
643  const char *help,
644  const char *script_callback,
645  HOM_EnumValue &script_callback_language,
646  const std::map<std::string, std::string> &tags,
647  const std::map<HOM_EnumValue, std::string> &conditionals,
648  const std::string &default_expression,
649  const HOM_EnumValue &default_expression_language) = 0;
650 
651  virtual HOM_MenuParmTemplate *newMenuParmTemplate(
652  const char *name,
653  const char *label,
654  const std::vector<std::string> &menu_items,
655  const std::vector<std::string> &menu_labels,
656  int default_value,
657  const std::vector<std::string> &icon_names,
658  const std::string &item_generator_script,
659  HOM_EnumValue *item_generator_script_language,
660  HOM_EnumValue &menu_type,
661  bool menu_use_token,
662  const char *disable_when,
663  bool is_hidden,
664  bool is_label_hidden,
665  bool join_with_next,
666  const char *help,
667  const char *script_callback,
668  HOM_EnumValue &script_callback_language,
669  const std::map<std::string, std::string> &tags,
670  const std::map<HOM_EnumValue, std::string> &conditionals,
671  const std::string &default_expression,
672  const HOM_EnumValue &default_expression_language,
673  bool store_default_value_as_string) = 0;
674 
675  virtual HOM_ButtonParmTemplate *newButtonParmTemplate(
676  const char *name,
677  const char *label,
678  const char *disable_when,
679  bool is_hidden,
680  bool is_label_hidden,
681  bool join_with_next,
682  const char *help,
683  const char *script_callback,
684  HOM_EnumValue &script_callback_language,
685  const std::map<std::string, std::string> &tags,
686  const std::map<HOM_EnumValue, std::string> &conditionals ) = 0;
687 
688  virtual HOM_LabelParmTemplate *newLabelParmTemplate(
689  const char *name,
690  const char *label,
691  const std::vector<std::string> &column_labels,
692  bool is_hidden,
693  bool is_label_hidden,
694  bool join_with_next,
695  const char *help,
696  const std::map<std::string, std::string> &tags,
697  const std::map<HOM_EnumValue, std::string> &conditionals) = 0;
698 
699  virtual HOM_SeparatorParmTemplate *newSeparatorParmTemplate(
700  const char *name,
701  bool is_hidden,
702  const std::map<std::string, std::string> &tags,
703  const std::map<HOM_EnumValue, std::string> &conditionals) = 0;
704 
705  virtual HOM_FolderSetParmTemplate *newFolderSetParmTemplate(
706  const char *name,
707  const std::vector<std::string> &folder_names,
708  HOM_EnumValue &folder_type,
709  const std::map<std::string, std::string> &tags) = 0;
710 
711  virtual HOM_FolderParmTemplate *newFolderParmTemplate(
712  const char *name,
713  const char *label,
714  const std::vector<HOM_ParmTemplate *> &parm_templates,
715  HOM_EnumValue &folder_type,
716  int default_value,
717  bool is_hidden,
718  bool ends_tab_group,
719  const char *script_callback,
720  HOM_EnumValue &script_callback_language,
721  const std::map<std::string, std::string> &tags,
722  const std::map<HOM_EnumValue, std::string> &conditionals) = 0;
723 
724  virtual HOM_RampParmTemplate *newRampParmTemplate(
725  const char *name,
726  const char *label,
727  HOM_EnumValue &ramp_parm_type,
728  int default_value,
729  HOM_EnumValue *default_basis,
730  bool show_controls,
732  const char *disable_when,
733  bool is_hidden,
734  const char *help,
735  const char *script_callback,
736  HOM_EnumValue &script_callback_language,
737  const std::map<std::string, std::string> &tags,
738  const std::map<HOM_EnumValue, std::string> &conditionals,
739  const std::string &default_expression,
740  const HOM_EnumValue &default_expression_language) = 0;
741 
742  virtual HOM_ParmTemplateGroup *newParmTemplateGroup(
743  const std::vector<HOM_ParmTemplate *> &parm_templates) = 0;
744 
745  virtual HOM_PerfMonRecordOptions *newPerfMonRecordOptions(
746  bool cook_stats, bool solve_stats, bool draw_stats,
747  bool gpu_draw_stats, bool viewport_stats, bool script_stats,
748  bool render_stats, bool thread_stats, bool frame_stats,
749  bool memory_stats, bool errors) = 0;
750 
751 
752  virtual HOM_Keyframe *newKeyframe() = 0;
753  virtual HOM_Keyframe *newKeyframe(double value) = 0;
754  virtual HOM_Keyframe *newKeyframe(double value, double time) = 0;
755  virtual HOM_Keyframe *newKeyframe(const HOM_Keyframe &keyframe) = 0;
756 
757  virtual HOM_StringKeyframe *newStringKeyframe() = 0;
758  virtual HOM_StringKeyframe *newStringKeyframe(
759  const std::string &value, HOM_EnumValue &language) = 0;
760  virtual HOM_StringKeyframe *newStringKeyframe(
761  const std::string &value, double time, HOM_EnumValue &language) = 0;
762  virtual HOM_StringKeyframe *newStringKeyframe(
763  const HOM_StringKeyframe &string_keyframe) = 0;
764 
765  virtual HOM_HDAOptions *newHDAOptions() = 0;
766  virtual HOM_LopSelectionRule *newLopSelectionRule() = 0;
767 
768  virtual HOM_InterruptableOperation *newInterruptableOperation(
769  const char *operation_name, const char *long_operation_name,
770  bool open_interrupt_dialog) = 0;
771 
772  virtual HOM_RedrawBlock *newRedrawBlock() = 0;
773 #ifndef SWIG
774  virtual HOM_RedrawResumeBlock *newRedrawResumeBlock() = 0;
775 #endif
776 
777  virtual HOM_StyleSheet *newStyleSheet() = 0;
778  virtual HOM_StyleSheet *newStyleSheet(const char *json_text) = 0;
779 
780  virtual HOM_Selection *newSelection(HOM_EnumValue &selection_type,
781  HOM_Geometry *geo, const char *selection_string) = 0;
782  virtual HOM_Selection *newSelection(
783  const std::vector<HOM_EnumValue *> &selection_types,
784  HOM_Geometry *geo, const char *selection_string) = 0;
785  virtual HOM_Selection *newSelection(
786  const std::vector<HOM_Prim *> &prims) = 0;
787  virtual HOM_Selection *newSelection(
788  const std::vector<HOM_Point *> &points) = 0;
789  virtual HOM_Selection *newSelection(
790  const std::vector<HOM_Vertex *> &vertices) = 0;
791  virtual HOM_Selection *newSelection(
792  const std::vector<HOM_Edge *> &edges) = 0;
793 
794  // This method returns a new HOM_Geometry object.
795  virtual HOM_Geometry *newGeometry() = 0;
796  virtual HOM_Geometry *newGeometry(HOM_Geometry &) = 0;
797 
798  virtual HOM_AgentDefinition *newAgentDefinition(
799  const HOM_AgentRig &rig, const HOM_AgentShapeLibrary &shapelib) = 0;
800 
801  virtual HOM_AgentClip *newAgentClip(
802  const char *name, const char *path, const HOM_AgentRig &rig,
803  bool keep_external_ref) = 0;
804 
805  virtual HOM_AgentClip *newAgentClip(
806  const char *name, HOM_ChopNode &chop, const HOM_AgentRig &rig,
807  double frame) = 0;
808 
809  virtual HOM_AgentClip *newAgentClip(
810  const HOM_AgentClip &clip, const HOM_AgentRig &rig,
811  const char *name) = 0;
812 
813  virtual HOM_AgentRig *newAgentRig(const char *path, bool keep_external_ref) = 0;
814 
815  virtual HOM_AgentRig *newAgentRig(
816  const char *name, const std::vector<std::string> &transform_names,
817  const std::vector<std::vector<int>> &hierarchy) = 0;
818 
819  virtual HOM_AgentTransformGroup *newAgentTransformGroup(
820  const char *path, const HOM_AgentRig &rig,
821  bool keep_external_ref = true) = 0;
822 
823  virtual HOM_AgentTransformGroup *newAgentTransformGroup(
824  const char *name, const std::vector<int> &transforms,
825  const HOM_AgentRig &rig, const std::vector<double> &weights) = 0;
826 
827  virtual HOM_AgentShapeLibrary *newAgentShapeLibrary() = 0;
828  virtual HOM_AgentShapeLibrary *newAgentShapeLibrary(
829  const char *path, bool keep_external_ref) = 0;
830 
831  virtual HOM_AgentShapeBinding *
832  newAgentShapeBinding(int transform, const HOM_AgentShape &shape,
833  bool deforming, double bounds_scale) = 0;
834 
835  virtual HOM_AgentShapeBinding *
836  newAgentShapeBinding(int transform, const HOM_AgentShape &shape,
837  const HOM_AgentShapeDeformer &deformer,
838  double bounds_scale) = 0;
839 
840  virtual HOM_AgentLayer *newAgentLayer(
841  const char *name, const HOM_AgentRig &rig,
842  const HOM_AgentShapeLibrary &shapelib,
843  const std::vector<HOM_AgentShapeBinding *> &shape_bindings,
844  const HOM_AgentLayer *source_layer = 0) = 0;
845 
846  virtual HOM_AgentLayer *
847  newAgentLayer(const char *path, const HOM_AgentRig &rig,
848  const HOM_AgentShapeLibrary &shapelib,
849  bool keep_external_ref = true) = 0;
850 
851  virtual bool compareNode(const char *path, const char *dest = NULL) = 0;
852  virtual bool compareNodeBackup(const char *path, int index,
853  const char *dest = NULL) = 0;
854  virtual bool compareHDA(const char *path_left, const char *path_right,
855  const char *dest = NULL) = 0;
856  virtual bool compareHDABackup(const char *path, int index,
857  const char *dest = NULL) = 0;
858  virtual bool compareHip(const char *dest = NULL) = 0;
859  virtual bool compareHipBackup(int index, const char *dest = NULL) = 0;
860 
861  virtual bool hasContextOption(const char *opt) = 0;
862  virtual UT_OptionEntry *contextOption(const char *opt) = 0;
863  virtual std::vector<std::string> contextOptionNames() = 0;
864  virtual void setDefaultContextOption(const char *opt,
865  const char *value, const char *ui_config = nullptr) =0;
866  virtual void setDefaultContextOption(const char *opt,
867  double value, const char *ui_config = nullptr) = 0;
868 
869  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
870 
871  // This method is called when orbolt_url runs. It is not wrapped by swig.
872  virtual void setOrboltURLHandler(
873  STORUI_OrboltURLHandler &orbolt_url_handler) = 0;
874 
875  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
876 
877  // These methods are used to help debug HOM to make sure no objects
878  // get allocated that don't get deallocated.
879  virtual void constructObject(void *pointer, const std::type_info &type) = 0;
880  virtual void destructObject(void *pointer, const std::type_info &type) = 0;
881  virtual std::map<std::string, int> objectCounts() = 0;
882 
883  // Preferences
884  virtual std::vector<std::string> getPreferenceNames() = 0;
885  virtual std::string getPreference(const char *name) = 0;
886  virtual bool setPreference(const char *name, const char* value) = 0;
887 
888  virtual HOM_ViewerStateTemplate * newViewerStateTemplate(
889  std::string const & type_name,
890  std::string const & label,
891  HOM_NodeTypeCategory const & category) = 0;
892 
893  virtual HOM_ViewerStateMenu * newViewerStateMenu(std::string const & handle, std::string const & label) = 0;
894 
895  virtual HOM_Drawable * newDrawable( HOM_SceneViewer& scene_viewer, HOM_EnumValue const &prim_type, std::string const &name ) = 0;
896  virtual HOM_Drawable * newDrawable( HOM_SceneViewer& scene_viewer, HOM_Geometry const &geometry, std::string const &name ) = 0;
897 
898  virtual HOM_UIEvent * newUIEvent( int64 val ) = 0;
899  virtual HOM_ViewerEvent * newViewerEvent( HOM_SceneViewer& sceneViewer, int64 val ) = 0;
900  virtual HOM_UIEventDevice * newUIEventDevice(int64 val, int64 val2) = 0;
901 
902  virtual void startHoudiniEngineDebugger(unsigned short port) = 0;
903  virtual void startHoudiniEngineDebugger(const char *pipe_name) = 0;
904 
905  virtual HOM_GeometrySelection * newGeometrySelection() = 0;
906  virtual HOM_GeometrySelection * newGeometrySelection(int64 val) = 0;
907 
908  virtual HOM_BinaryString convertClipData(HOM_BinaryString data,
909  bool from_binary,
910  bool from_blosc_compression,
911  bool to_binary,
912  bool to_blosc_compression) = 0;
913 
914  virtual HOM_BinaryString convertKeyframesToClipData(
915  const std::map<std::string, std::vector<HOM_Keyframe *>> &keyframe_map,
916  bool binary = true, bool use_blosc_compression = true) = 0;
917 
918  virtual std::string _clipInfo(HOM_BinaryString data, bool binary = true,
919  bool blosc_compressed = true) = 0;
920 
921  virtual std::vector<HOM_ElemPtr<HOM_Node> > _nodesFromOPNodeList(int64 val) = 0;
922 
923 private:
924  // HOMF_Module::createHOMModule() uses this to create the HOM_Module.
925  static void (*theHOMCreator)();
926 
927  // A subclass of HOM_Module in the HOMF library will define the
928  // implementation of HOM. Importing the python module will set the
929  // implementation, so this function should only be called by HOMF_Module::
930  // createHOMModule().
931  friend class HOMF_Module;
932  static void setImplementation(HOM_Module* implementation);
933 
934  // We could add a static method to access the implementation, but we
935  // want to make it easy to access the HOM module from C++. So, the
936  // global function HOM() needs access to the implementation.
937  friend HOM_API HOM_Module& HOM();
938  static HOM_Module *theImplementation;
939 };
940 
941 
942 // Use this function to automatically delete objects for functions that
943 // return new objects. This lets you, for example, write code like
944 // HOMdel(HOM().findNode("/obj/geo1"))->setName("geo2")
945 template <typename T>
947 { return UT_UniquePtr<T>(hom_object); }
948 
949 
950 // This lock is used to synchronize HOM scripts running in a separate
951 // thread and Houdini. Houdini's UI queue will give up the lock when it's
952 // waiting for events and reacquire it when it handles an event.
953 //
954 // Note that this lock allows multiple threads in the same thread group to hold
955 // it at the same time. By default, a thread started from Houdini is added to
956 // the group containing the main thread. This way, since Houdini started the
957 // thread, we can be confident that it will use other locks to synchronize
958 // access to Houdini. This approach allows, for example, a volume SOP to
959 // cook using multiple threads, evaluating Python in each thread while the
960 // main thread holds the HOM lock, without deadlocking and without allowing
961 // non-Houdini threads to acquire the HOM lock. (Note that the GIL will
962 // synchronize access to Python's internals.)
965 {
966  // This is not thread-safe but should be ok because HOMgetLock() is called
967  // pretty early on during startup when there is only one thread executing.
968  if (!HOM_theHOMLock)
970 
972  return *HOM_theHOMLock;
973 }
974 
975 // The HOM implementation uses the HOM_AutoLock to make sure Houdini isn't busy
976 // when they make calls into the Houdini libraries. Note that constructing
977 // a HOM_AutoLock will release the python global interpreter lock (GIL) if
978 // it was held before acquiring the HOM lock. This way, other python threads
979 // can run if it needs to block waiting for the HOM lock.
981 {
982 public:
984  {
985  if (!HOMgetLock().hasLock())
986  {
987  HOMgetLock().lock();
988  myLocked = true;
989  }
990  else
991  myLocked = false;
992  }
993 
995  {
996  if (myLocked)
997  HOMgetLock().unlock();
998  }
999 
1000 private:
1001 
1002  // It is important that we release the python global interpreter lock
1003  // (GIL) for the duration of waiting for, acquiring and holding onto
1004  // the HOM lock. This gives other threads that are either blocked
1005  // on the GIL or that will try to acquire the GIL a chance to continue
1006  // execution.
1007  //
1008  // If the current thread needs to access the Python API,
1009  // then it should explicitly acquire the GIL by creating a
1010  // PY_InterpreterAutoLock object. The PY_InterpreterAutoLock must be
1011  // constructed *after* the HOM_AutoLock or it will have no effect.
1012  //
1013  // This prevents deadlocks that occur when the current thread
1014  // spawns other threads which access the Python API and try to
1015  // acquire the GIL.
1016  //
1017  // Note that we will reacquire the GIL when the HOM auto lock is destructed.
1018  PY_InterpreterAutoUnlock myPyInterpAutoUnlock;
1019 
1020  // Boolean to determine if the auto lock actually locked the HOM lock.
1021  bool myLocked;
1022 };
1023 
1024 // The HOM implementation uses HOM_AutoUnlock to allow the main thread to
1025 // run while waiting for something to happen. Constructing a HOM_AutoUnlock
1026 // instance will release the HOM lock but not the Python GIL. When it's
1027 // destructed it will reacquire the HOM lock. Since it releases the HOM lock,
1028 // it's important that a HOM_AutoLock was already created in a containing
1029 // scope.
1030 //
1031 // Use HOM_AutoUnlock in conjunction with PY_InterpreterAutoUnlock to
1032 // also release the Python GIL. Be sure to create the HOM_AutoUnlock *after*
1033 // the PY_InterpreterAutoUnlock, so that when the auto locks are destructed
1034 // the HOM lock is reacquired before the Python GIL. Otherwise, it will grab
1035 // the GIL and then try to grab the HOM lock, and if another thread with the
1036 // HOM lock tries to run Python we'll end up with deadlock.
1038 {
1039 public:
1041  { HOMgetLock().unlock(); }
1042 
1044  { HOMgetLock().lock(); }
1045 };
1046 
1047 
1048 // These macros are used to help detect memory leaks when debugging is enabled.
1049 #ifdef HOM_DEBUG
1050 #define HOM_CONSTRUCT_OBJECT(pointer) \
1051  HOM().constructObject(pointer, typeid(*pointer));
1052 #define HOM_DESTRUCT_OBJECT(pointer) \
1053  HOM().destructObject(pointer, typeid(*pointer));
1054 #else
1055 #define HOM_CONSTRUCT_OBJECT(pointer)
1056 #define HOM_DESTRUCT_OBJECT(pointer)
1057 #endif
1058 
1059 // gcc gets a parse error if we try to give a default map value in the
1060 // signature, and the typedef avoids the error.
1061 typedef std::map<std::string, std::string> HOM_StdMapStringString;
1062 typedef std::map<HOM_EnumValue, std::string> HOM_StdMapEnumString;
1063 
1064 
1065 // Houdini will call HOMextendLibrary() in HDK dso's so the user can install
1066 // C++ HOM extensions.
1067 extern "C" {
1069 }
1070 
1071 #endif
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2544
png_infop int transforms
Definition: png.h:2591
#define SYS_VISIBILITY_EXPORT
UT_TaskRootLock & HOMgetLock()
Definition: HOM_Module.h:964
GT_API const UT_StringHolder time
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
GLuint color
Definition: glcorearb.h:1260
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
const GLuint GLenum const void * binary
Definition: glcorearb.h:1923
GLsizei const GLchar *const * path
Definition: glcorearb.h:3340
UT_UniquePtr< T > HOMdel(T *hom_object)
Definition: HOM_Module.h:946
GLint y
Definition: glcorearb.h:102
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glcorearb.h:2538
GLint GLsizei width
Definition: glcorearb.h:102
Definition: HOM_qt.h:19
long long int64
Definition: SYS_Types.h:107
UT_TaskLockT< false > UT_TaskRootLock
Definition: UT_TaskLock.h:281
HOM_API UT_TaskRootLock * HOM_theHOMLock
#define HOM_API
Definition: HOM_API.h:13
const std::enable_if<!VecTraits< T >::IsVec, T >::type & max(const T &a, const T &b)
Definition: Composite.h:133
virtual ~HOM_Module()
Definition: HOM_Module.h:143
GLsizei GLsizei GLchar * source
Definition: glcorearb.h:802
Definition: HOM_ui.h:41
GLfloat units
Definition: glcorearb.h:407
GLboolean * data
Definition: glcorearb.h:130
GLuint const GLchar * name
Definition: glcorearb.h:785
GA_API const UT_StringHolder transform
std::map< HOM_EnumValue, std::string > HOM_StdMapEnumString
Definition: HOM_Module.h:1062
GLenum mode
Definition: glcorearb.h:98
GLint GLsizei GLsizei height
Definition: glcorearb.h:102
GLenum GLint GLint * precision
Definition: glcorearb.h:1924
GLfloat GLfloat GLfloat GLfloat h
Definition: glcorearb.h:2001
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:270
SYS_VISIBILITY_EXPORT void HOMextendLibrary()
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER T clip(const T &p, const Box< T > &box)
Definition: ImathBoxAlgo.h:89
GLenum void ** pointer
Definition: glcorearb.h:809
png_infop png_uint_32 png_uint_32 int int * color_type
Definition: png.h:2394
GLuint index
Definition: glcorearb.h:785
GLint GLenum GLint x
Definition: glcorearb.h:408
GLuint GLfloat * val
Definition: glcorearb.h:1607
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 GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:126
void unlock()
Definition: UT_TaskLock.h:253
Quat< T > spline(const Quat< T > &q0, const Quat< T > &q1, const Quat< T > &q2, const Quat< T > &q3, T t)
Definition: ImathQuat.h:545
HOM_API HOM_Module & HOM()
const std::enable_if<!VecTraits< T >::IsVec, T >::type & min(const T &a, const T &b)
Definition: Composite.h:129
static bool isImplementationSet()
Definition: HOM_Module.h:438
std::map< std::string, std::string > HOM_StdMapStringString
Definition: HOM_Module.h:1061
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794