HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HOM_Node.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  */
8 
9 #ifndef __HOM_Node_h__
10 #define __HOM_Node_h__
11 
12 #include "HOM_API.h"
13 #include "HOM_NetworkMovableItem.h"
14 #include "HOM_BinaryString.h"
15 #include "HOM_EnumModules.h"
16 #include "HOM_IterableList.h"
17 #include "HOM_PtrOrNull.h"
18 #include <PY/PY_OpaqueObject.h>
19 #include <string>
20 #include <vector>
21 
22 class HOM_StickyNote;
23 class HOM_NodeConnection;
24 class HOM_NodeGroup;
25 class HOM_NodeType;
26 class HOM_NodeTypeCategory;
27 class HOM_Parm;
28 class HOM_ParmTuple;
29 class HOM_IndirectInput;
30 class HOM_SubnetIndirectInput;
31 class HOM_HDAModule;
32 class HOM_HDAViewerHandleModule;
33 class HOM_HDAViewerStateModule;
34 class HOM_ParmTemplate;
35 class HOM_DopSimulation;
36 class HOM_DopObject;
37 class HOM_ParmTemplateGroup;
38 class HOM_NodeInfoTree;
39 class CL_Clip;
40 
41 SWIGOUT(%rename(Node) HOM_Node;)
42 
43 class HOM_API HOM_Node : virtual public HOM_NetworkMovableItem
44 {
45 public:
46  HOM_Node()
47  : HOM_NetworkMovableItem(HOM_networkItemType::Node)
48  { HOM_CONSTRUCT_OBJECT(this) }
49  HOM_Node(const HOM_Node &node)
50  : HOM_NetworkMovableItem(node)
51  { HOM_CONSTRUCT_OBJECT(this) }
52  ~HOM_Node() override
53  { HOM_DESTRUCT_OBJECT(this) }
54 
55  virtual std::vector<std::string> _getArgumentAutoComplete(
56  const char *method_name, const char *arguments,
57  bool meta_info_only = false) = 0;
58 
59  int __hash__() override = 0;
60 
61  virtual std::string __repr__() = 0;
62 
63  virtual bool operator==(HOM_PtrOrNull<HOM_Node> node) = 0;
64  virtual bool operator!=(HOM_PtrOrNull<HOM_Node> node) = 0;
65 
66  virtual std::string __str__() = 0;
67 
68  SWIGOUT(%kwargs infoTree;)
69  virtual HOM_NodeInfoTree infoTree(
70  bool verbose = false, bool debug = false, int output_index = 0) = 0;
71  virtual bool isNetwork() = 0;
72 
73  SWIGOUT(%newobject type;)
74  SWIGOUT(%warnfilter(321) type;)
75  virtual HOM_NodeType *type() = 0;
76 
77  virtual HOM_NodeTypeCategory *childTypeCategory() = 0;
78 
79  virtual bool isFlagReadable(HOM_EnumValue &flag) = 0;
80  virtual bool isFlagWritable(HOM_EnumValue &flag) = 0;
81  virtual bool isGenericFlagSet(HOM_EnumValue &flag) = 0;
82  virtual void setGenericFlag(HOM_EnumValue &flag, bool value) = 0;
83 
84  virtual bool isDisplayDescriptiveNameFlagSet() = 0;
85  virtual void setDisplayDescriptiveNameFlag(bool on) = 0;
86  virtual int outputForViewFlag() = 0;
87  virtual void setOutputForViewFlag(int output) = 0;
88 
89  // We need a quick way to get the OP_OpTypeId from C++ code so we know
90  // which subclass of HOM_Node we should cast to, so that's why
91  // opTypeIdAsInt() exists.
92  SWIGOUT(%ignore opTypeIdAsInt;)
93  virtual int opTypeIdAsInt() = 0;
94  // Further, we need a quick way to get the OBJ_OBJECT_TYPE from C++ code
95  // so we know which subclass of HOM_ObjNode we should cast to.
96  // That's why objTypeAsInt() exists.
97  SWIGOUT(%ignore objTypeAsInt;)
98  virtual int objTypeAsInt() = 0;
99 
100  SWIGOUT(%newobject node;)
101  SWIGOUT(%kwargs node;)
102  virtual HOM_Node* node(const char* node_path) = 0;
103 
104  SWIGOUT(%kwargs nodes;)
105  virtual std::vector<HOM_ElemPtr<HOM_Node> > nodes(
106  const std::vector<std::string>& node_paths) = 0;
107 
108  SWIGOUT(%kwargs cookPathNodes;)
109  virtual std::vector<HOM_ElemPtr<HOM_Node> > cookPathNodes() = 0;
110 
111  SWIGOUT(%newobject item;)
112  SWIGOUT(%kwargs item;)
113  virtual HOM_NetworkMovableItem* item(const char* item_path) = 0;
114 
115  SWIGOUT(%kwargs items;)
116  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > items(
117  const std::vector<std::string>& item_paths) = 0;
118 
119  SWIGOUT(%kwargs glob;)
120  virtual std::vector<HOM_ElemPtr<HOM_Node> > glob(
121  const char *pattern, bool ignore_case=false) = 0;
122 
123  SWIGOUT(%kwargs recursiveGlob;)
124  virtual std::vector<HOM_ElemPtr<HOM_Node> > recursiveGlob(
125  const char *pattern,
126  HOM_EnumValue &filter = HOM_nodeTypeFilter::NoFilter,
127  bool include_subnets = true) = 0;
128 
129  SWIGOUT(%newobject createNode;)
130  SWIGOUT(%kwargs createNode;)
131  virtual HOM_Node* createNode(
132  const char* node_type_name,
133  const char* node_name=NULL,
134  bool run_init_scripts=true,
135  bool load_contents=true,
136  bool exact_type_name=false,
137  bool force_valid_node_name=false) = 0;
138  virtual void runInitScripts() = 0;
139  virtual void createOrMoveVisualizer(int output_index) = 0;
140 
141  virtual int inputIndex(const char *input_name) = 0;
142  virtual int outputIndex(const char *output_name) = 0;
143 
144  virtual void setInput(
145  int input_index,
146  HOM_NetworkMovableItem *item_to_become_input,
147  int output_index = 0) = 0;
148 
149  virtual void setNamedInput(
150  const char *input_name,
151  HOM_NetworkMovableItem *item_to_become_input,
152  const char *output_name) = 0;
153 
154  virtual void setNamedInput(
155  const char *input_name,
156  HOM_NetworkMovableItem *item_to_become_input,
157  int output_index) = 0;
158 
159  virtual void setFirstInput(
160  HOM_NetworkMovableItem *item_to_become_input,
161  int output_index = 0) = 0;
162 
163  SWIGOUT(%kwargs setNextInput;)
164  virtual void setNextInput(
165  HOM_NetworkMovableItem *item_to_become_input,
166  int output_index = 0,
167  bool unordered_only = false) = 0;
168 
169  virtual void insertInput(
170  int input_index,
171  HOM_NetworkMovableItem *item_to_become_input,
172  int output_index = 0) = 0;
173 
174  virtual int numOrderedInputs() = 0;
175 
176  virtual std::vector<HOM_ElemPtr<HOM_Node> > inputs() = 0;
177 
178  SWIGOUT(%warnfilter(321) input;)
179  virtual HOM_Node *input(int input_index) = 0;
180  virtual HOM_Node *inputFollowingOutputs(int input_index) = 0;
181 
182  virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> > inputConnections() = 0;
183 
184  SWIGOUT(%newobject inputConnectors;)
185  virtual HOM_IterableList<std::vector<HOM_ElemPtr<HOM_NodeConnection> > > *
186  inputConnectors() = 0;
187 
188  SWIGOUT(%kwargs inputAncestors;)
189  virtual std::vector<HOM_ElemPtr<HOM_Node> > inputAncestors(
190  bool include_ref_inputs = true,
191  bool follow_subnets = false,
192  bool only_used_inputs = false) = 0;
193 
194  virtual std::vector<std::string> inputNames() = 0;
195  virtual std::vector<std::string> inputLabels() = 0;
196 
197  virtual std::map<std::string, std::string> editableInputStrings(
198  int input_index) = 0;
199  virtual std::string editableInputString(int input_index,
200  const char *key) = 0;
201  virtual void setEditableInputString(int input_index,
202  const char *key, const char *value) = 0;
203 
204  virtual std::vector<std::string> outputNames() = 0;
205  virtual std::vector<std::string> outputLabels() = 0;
206 
207  virtual std::vector<HOM_ElemPtr<HOM_Node> > outputs() = 0;
208 
209  virtual std::vector<HOM_ElemPtr<HOM_NodeConnection> >
210  outputConnections() = 0;
211 
212  SWIGOUT(%newobject outputConnectors;)
213  virtual HOM_IterableList<std::vector<HOM_ElemPtr<HOM_NodeConnection> > > *
214  outputConnectors() = 0;
215 
216  // Dependency information.
217  SWIGOUT(%kwargs references;)
218  virtual std::vector<HOM_ElemPtr<HOM_Node> >
219  references(bool include_children=true) = 0;
220  SWIGOUT(%kwargs dependents;)
221  virtual std::vector<HOM_ElemPtr<HOM_Node> >
222  dependents(bool include_children=true) = 0;
223 
224  // Access things contained in this node (node must be a network).
225  virtual std::vector<HOM_ElemPtr<HOM_Node> > children() = 0;
226  SWIGOUT(%kwargs allSubChildren;)
227  virtual std::vector<HOM_ElemPtr<HOM_Node> > allSubChildren(
228  bool top_down = true, bool recurse_in_locked_nodes = true) = 0;
229  SWIGOUT(%kwargs selectedChildren;)
230  virtual std::vector<HOM_ElemPtr<HOM_Node> > selectedChildren(
231  bool include_hidden = false,
232  bool include_hidden_support_nodes = false) = 0;
233 
234  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > allItems() = 0;
235  SWIGOUT(%kwargs selectedItems;)
236  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > selectedItems(
237  bool include_hidden = false,
238  bool include_hidden_support_nodes = false) = 0;
239  SWIGOUT(%kwargs numItems;)
240  virtual int numItems(HOM_EnumValue *item_type = NULL,
241  bool selected_only = false,
242  bool include_hidden = false) = 0;
243 
244  // Picked child item copy/paste/delete methods.
245  SWIGOUT(%kwargs deleteItems;)
246  virtual void deleteItems(
247  const std::vector<HOM_NetworkMovableItem *>&
248  items = std::vector<HOM_NetworkMovableItem *>(),
249  bool disable_safety_checks = false) = 0;
250  virtual void copyItemsToClipboard(
251  const std::vector<HOM_NetworkMovableItem *> &items =
252  std::vector<HOM_NetworkMovableItem *>()) = 0;
253  virtual void pasteItemsFromClipboard(HOM_Vector2 *position = NULL) = 0;
254  SWIGOUT(%kwargs copyItems;)
255  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> > copyItems(
256  const std::vector<HOM_NetworkMovableItem *> &items,
257  bool channel_reference_originals=false,
258  bool relative_references=true,
259  bool connect_outputs_to_multi_inputs=false) = 0;
260 
261  SWIGOUT(%newobject creator;)
262  virtual HOM_Node *creator() = 0;
263  virtual bool isInsideLockedHDA() = 0;
264  virtual bool isEditableInsideLockedHDA() = 0;
265  virtual bool isEditable() = 0;
266  virtual bool isLockedHDA() = 0;
267  virtual bool isCompiled() = 0;
268  virtual bool isMaterialManager() = 0;
269 
270  SWIGOUT(%newobject hdaModule;)
271  virtual HOM_HDAModule *hdaModule() = 0;
272 
273  SWIGOUT(%newobject hdaViewerStateModule;)
274  virtual HOM_HDAViewerStateModule *hdaViewerStateModule() = 0;
275 
276  SWIGOUT(%newobject hdaViewerHandleModule;)
277  virtual HOM_HDAViewerHandleModule *hdaViewerHandleModule() = 0;
278 
279  // hm is an alias for hdaModule.
280  SWIGOUT(%newobject hm;)
281  virtual HOM_HDAModule *hm()
282  { return hdaModule(); }
283 
284  SWIGOUT(%newobject moveToGoodPosition;)
285  SWIGOUT(%kwargs moveToGoodPosition;)
286  virtual HOM_Vector2 *moveToGoodPosition(bool relative_to_inputs = true,
287  bool move_inputs = true,
288  bool move_outputs = true,
289  bool move_unconnected = true) = 0;
290 
291  // TODO: Have an argument to specify sorting orders once bug 25998 is fixed.
292  // Have an argument equivalent to oplayout -t once bug 26018 is fixed.
293  SWIGOUT(%kwargs layoutChildren);
294  virtual void layoutChildren
295  (const std::vector<HOM_NetworkMovableItem *> &items =
296  std::vector<HOM_NetworkMovableItem *>(),
297  double horizontal_spacing=-1, double vertical_spacing=-1) = 0;
298 
299  virtual bool isCurrent() = 0;
300  SWIGOUT(%kwargs setCurrent;)
301  virtual void setCurrent(bool on, bool clear_all_selected = false) = 0;
302 
303  virtual bool isHidden() = 0;
304  virtual void hide(bool on) = 0;
305 
306  virtual std::string comment() = 0;
307  virtual void setComment(const char *comment) = 0;
308  virtual void appendComment(const char *comment) = 0;
309 
310  virtual std::string creatorState() = 0;
311  virtual void setCreatorState(const char *state) = 0;
312 
313  virtual bool isBuiltExplicitly() = 0;
314  virtual void setBuiltExplicitly(bool built_explicitly) = 0;
315 
316  virtual HOM_EnumValue *expressionLanguage() = 0;
317  virtual void setExpressionLanguage(HOM_EnumValue &language) = 0;
318 
319  SWIGOUT(%newobject parm;)
320  virtual HOM_Parm *parm(const char* parm_path) = 0;
321 
322  SWIGOUT(%newobject parmTuple;)
323  virtual HOM_ParmTuple *parmTuple(const char* parm_path) = 0;
324 
325  SWIGOUT(%kwargs globParms;)
326  virtual std::vector<HOM_ElemPtr<HOM_Parm> > globParms(
327  const char *pattern, bool ignore_case=false,
328  bool search_label=false,
329  bool single_pattern=false) = 0;
330 
331  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parms() = 0;
332 
333  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsReferencingThis() = 0;
334 
335  virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuples() = 0;
336 
337  virtual std::vector<HOM_ElemPtr<HOM_Parm> > spareParms() = 0;
338  virtual void removeSpareParms() = 0;
339 
340  virtual void syncNodeVersionIfNeeded(const std::string &from_version) = 0;
341 
342  SWIGOUT(%kwargs setParmTemplateGroup;)
343  virtual void setParmTemplateGroup(
344  HOM_ParmTemplateGroup &parm_template_group,
345  bool rename_conflicting_parms=false) = 0;
346 
347 
348  virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuplesInFolder(
349  const std::vector<std::string> &folder_names) = 0;
350 
351  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsInFolder(
352  const std::vector<std::string> &folder_names) = 0;
353 
354  SWIGOUT(%newobject parmTemplateGroup;)
355  virtual HOM_ParmTemplateGroup *parmTemplateGroup() = 0;
356 
357  virtual std::vector<std::string> localVariables() = 0;
358  virtual std::vector<std::string> localAttributes() = 0;
359 
360  virtual bool isTimeDependent() = 0;
361 
362  SWIGOUT(%kwargs destroy;)
363  virtual void destroy(bool disable_safety_checks=false) = 0;
364 
365  // If propagate==true, unlock will be propagated to ancestors
366  SWIGOUT(%kwargs allowEditingOfContents;)
367  virtual void allowEditingOfContents(bool propagate=false) = 0;
368  virtual void matchCurrentDefinition() = 0;
369  virtual bool matchesCurrentDefinition() = 0;
370 
371  SWIGOUT(%kwargs parmAliases;)
372  virtual std::map<HOM_ElemPtr<HOM_Parm>, std::string>
373  parmAliases(bool recurse=false) = 0;
374 
375  virtual void clearParmAliases() = 0;
376 
377  virtual std::vector<HOM_ElemPtr<HOM_NetworkBox> > networkBoxes() = 0;
378 
379  SWIGOUT(%newobject iterNetworkBoxes;)
380  virtual HOM_IterableList<HOM_NetworkBox> *iterNetworkBoxes() = 0;
381 
382  SWIGOUT(%newobject createNetworkBox;)
383  virtual HOM_NetworkBox *createNetworkBox(const char *name=NULL) = 0;
384 
385  SWIGOUT(%newobject copyNetworkBox;)
386  virtual HOM_NetworkBox *copyNetworkBox(HOM_NetworkBox &network_box_to_copy,
387  const char *new_name=NULL, bool channel_reference_original=false) = 0;
388 
389  SWIGOUT(%newobject findNetworkBox;)
390  virtual HOM_NetworkBox *findNetworkBox(const char *name) = 0;
391 
392  virtual std::vector<HOM_ElemPtr<HOM_NetworkBox> >
393  findNetworkBoxes(const char *pattern) = 0;
394 
395  virtual std::vector<HOM_ElemPtr<HOM_NetworkDot> > networkDots() = 0;
396 
397  SWIGOUT(%newobject createNetworkDot;)
398  virtual HOM_NetworkDot *createNetworkDot() = 0;
399 
400  SWIGOUT(%kwargs changeNodeType);
401  SWIGOUT(%newobject changeNodeType;)
402  virtual HOM_Node *changeNodeType(const char *new_node_type,
403  bool keep_name=true, bool keep_parms=true,
404  bool keep_network_contents=true,
405  bool force_change_on_node_type_match=false) = 0;
406 
407  virtual bool canCreateDigitalAsset() = 0;
408  SWIGOUT(%kwargs createDigitalAsset);
409  SWIGOUT(%newobject createDigitalAsset;)
410  virtual HOM_Node *createDigitalAsset(const char *name=NULL,
411  const char *hda_file_name=NULL, const char *description=NULL,
412  int min_num_inputs=0, int max_num_inputs=0,
413  bool compress_contents=false, const char *comment=NULL,
414  const char *version=NULL, bool save_as_embedded=false,
415  bool ignore_external_references=false,
416  bool compile_asset = false,
417  bool change_node_type = true,
418  bool create_backup = true,
419  const char *install_path=NULL) = 0;
420 
421  SWIGOUT(%kwargs createCompiledDigitalAsset);
422  virtual void createCompiledDigitalAsset(const char *name=NULL,
423  const char *hda_file_name=NULL, const char *description=NULL) = 0;
424 
425  // Sub-Network methods.
426  SWIGOUT(%kwargs collapseIntoSubnet;)
427  SWIGOUT(%newobject collapseIntoSubnet;)
428  virtual HOM_Node *collapseIntoSubnet(
429  const std::vector<HOM_NetworkMovableItem*> &child_items,
430  const char *subnet_name=NULL, const char *subnet_type=NULL) = 0;
431 
432  virtual std::vector<HOM_ElemPtr<HOM_NetworkMovableItem> >
433  extractAndDelete() = 0;
434 
435  virtual std::vector<HOM_ElemPtr<HOM_SubnetIndirectInput> >
436  indirectInputs() = 0;
437 
438  // get the nodes inside a subnet that feed its outputs
439  virtual std::vector<HOM_ElemPtr<HOM_Node> >
440  subnetOutputs() = 0;
441 
442  virtual bool isSubNetwork() = 0;
443 
444  // User data methods:
445  virtual void setUserData(const char *name, const std::string &value) = 0;
446  SWIGOUT(%ignore boostAnyUserData;)
447  virtual hboost::any boostAnyUserData(const char *name) = 0;
448  virtual void destroyUserData(const char *name) = 0;
449  virtual void clearUserDataDict() = 0;
450 #if defined(USE_PYTHON3)
451  virtual std::map<std::string, std::string> userDataDict() = 0;
452 #else
453  virtual std::map<std::string, HOM_BinaryString> userDataDict() = 0;
454 #endif
455 
456  // TOPs work item navigation, these are here
457  // so both TopNode and SopNode (for sop top networks)
458  // can call them
459  virtual void selectNextVisibleWorkItem() = 0;
460  virtual void selectPreviousVisibleWorkItem() = 0;
461  virtual void deselectWorkItem() = 0;
462  virtual void setCurrentTOPPage(int page) = 0;
463 
464 #ifdef SWIG
465 %extend
466 {
467  InterpreterObject userData(const char *name)
468  { return HOMboostAnyToInterpreterObject(self->boostAnyUserData(name)); }
469 }
470 #endif
471 
472 
473  // Cached user data methods:
474  SWIGOUT(%ignore setOpaqueCachedUserData;)
475  virtual void setOpaqueCachedUserData(
476  const char *name, void *opaque_py_object) = 0;
477  SWIGOUT(%ignore opaqueCachedUserData;)
478  virtual void *opaqueCachedUserData(const char *name) = 0;
479  virtual void destroyCachedUserData(const char *name) = 0;
480  virtual void clearCachedUserDataDict() = 0;
481  virtual std::map<std::string, PY_OpaqueObject> cachedUserDataDict() = 0;
482 
483 #ifdef SWIG
484 %extend
485 {
486  void setCachedUserData(const char *name, InterpreterObject value)
487  { return self->setOpaqueCachedUserData(name, value); }
488 
489  InterpreterObject cachedUserData(const char *name)
490  { return HOMincRef((InterpreterObject)self->opaqueCachedUserData(name)); }
491 }
492 #endif
493 
494  // Data Block methods (like user data, but bigger blobs with associated
495  // data types).
496  virtual std::vector<std::string> dataBlockKeys(
497  const char *blocktype = nullptr) = 0;
498  virtual std::string dataBlockType(const char *key) = 0;
499  virtual HOM_BinaryString dataBlock(const char *key) = 0;
500  virtual void setDataBlock(const char *key, HOM_BinaryString data,
501  const char *blocktype) = 0;
502  virtual void removeDataBlock(const char *key) = 0;
503 
504  // asCode methods:
505  SWIGOUT(%kwargs asCode;)
506  virtual std::string asCode(bool brief=false,
507  bool recurse=false,
508  bool save_channels_only=false,
509  bool save_creation_commands=true,
510  bool save_keys_in_frames=false,
511  bool save_outgoing_wires=false,
512  bool save_parm_values_only=false,
513  bool save_spare_parms=true,
514  const char *function_name=NULL) = 0;
515 
516  virtual bool canGenerateCookCode(bool check_parent=false,
517  bool check_auto_shader=true) = 0;
518  SWIGOUT(%newobject cookCodeGeneratorNode;)
519  virtual HOM_Node *cookCodeGeneratorNode() = 0;
520  virtual std::string cookCodeLanguage() = 0;
521  virtual bool supportsMultiCookCodeContexts() = 0;
522 
523 
524  SWIGOUT(%kwargs saveCookCodeToFile;)
525  virtual void saveCookCodeToFile(
526  const char *file_name, bool skip_header=false,
527  const char *context_name = NULL) = 0;
528 
529  // This method is deprecated.
530  void saveCodeToFile(const char *file_name, bool skip_header=false,
531  const char *context_name = NULL)
532  { saveCookCodeToFile(file_name, skip_header, context_name); }
533 
534 
535  virtual void saveCompiledCookCodeToFile(const char *file_name,
536  const char *context_name = NULL) = 0;
537 
538  // This method is deprecated.
539  void saveToCompiledVexFile(const char *file_name,
540  const char *context_name = NULL)
541  { saveCompiledCookCodeToFile(file_name, context_name); }
542 
543 
544  SWIGOUT(%kwargs cook;)
545  virtual void cook(
546  bool force = false,
547  const std::vector<double> frame_range = std::vector<double>()) = 0;
548 
549  SWIGOUT(%kwargs cookNoInterruptInternal;)
550  virtual void _cookNoInterruptInternal(
551  bool force = false,
552  const std::vector<double> frame_range = std::vector<double>()) = 0;
553 
554  /// Determine if this node to cook at the current evaluation time
555  virtual bool needsToCook() = 0;
556  /// Determine if this node to cook at the given time
557  virtual bool needsToCook(double time) = 0;
558 
559  virtual int cookCount() = 0;
560 
561  virtual void updateParmStates() = 0;
562 
563  virtual std::string deleteScript() = 0;
564  virtual void setDeleteScript(const std::string &script_text,
565  HOM_EnumValue &language = HOM_scriptLanguage::Python) = 0;
566 
567  // Sticky methods
568  SWIGOUT(%newobject createStickyNote;)
569  virtual HOM_StickyNote *createStickyNote(const char *name=NULL) = 0;
570 
571  virtual std::vector<HOM_ElemPtr<HOM_StickyNote> > stickyNotes() = 0;
572 
573  SWIGOUT(%newobject iterStickyNotes;)
574  virtual HOM_IterableList<HOM_StickyNote> *iterStickyNotes() = 0;
575 
576  SWIGOUT(%newobject copyStickyNote;)
577  virtual HOM_StickyNote *copyStickyNote(HOM_StickyNote &sticky_note_to_copy,
578  const char *new_name=NULL) = 0;
579 
580  SWIGOUT(%newobject findStickyNote;)
581  virtual HOM_StickyNote *findStickyNote(const char *name) = 0;
582 
583  SWIGOUT(%newobject findStickyNotes;)
584  virtual std::vector<HOM_ElemPtr<HOM_StickyNote> > findStickyNotes(
585  const char *pattern) = 0;
586 
587 
588  SWIGOUT(%newobject addNodeGroup;)
589  virtual HOM_NodeGroup *addNodeGroup(const char *name = NULL) = 0;
590 
591  virtual std::vector<HOM_ElemPtr<HOM_NodeGroup> > nodeGroups() = 0;
592 
593  SWIGOUT(%newobject nodeGroup;)
594  virtual HOM_NodeGroup *nodeGroup(const char *name) = 0;
595 
596  virtual std::vector<std::string> errors() = 0;
597  virtual std::vector<std::string> warnings() = 0;
598  virtual std::vector<std::string> messages() = 0;
599 
600  virtual std::string motionEffectsNetworkPath() = 0;
601  SWIGOUT(%newobject findOrCreateMotionEffectsNetwork;)
602  virtual HOM_Node *findOrCreateMotionEffectsNetwork(bool create=true) = 0;
603 
604  SWIGOUT(%kwargs saveItemsToFile;)
605  virtual void saveItemsToFile(
606  const std::vector<HOM_NetworkMovableItem *> &items,
607  const char *file_name,
608  bool save_hda_fallbacks = false) = 0;
609  SWIGOUT(%kwargs loadItemsFromFile;)
610  virtual void loadItemsFromFile(
611  const char *file_name, bool ignore_load_warnings=false) = 0;
612 
613  SWIGOUT(%ignore addOpaqueEventCallback;)
614  virtual void addOpaqueEventCallback(
615  const std::vector<HOM_EnumValue *> &event_types,
616  void *py_callback) = 0;
617  SWIGOUT(%ignore addOpaqueParmCallback;)
618  virtual void addOpaqueParmCallback(
619  void *py_callback,
620  const std::vector<std::string> &names) = 0;
621  SWIGOUT(%ignore removeOpaqueEventCallback;)
622  virtual void removeOpaqueEventCallback(
623  const std::vector<HOM_EnumValue *> &event_types,
624  void *py_callback) = 0;
625  virtual void removeAllEventCallbacks() = 0;
626  SWIGOUT(%ignore opaqueEventCallbacks;)
627  virtual std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
628  opaqueEventCallbacks() = 0;
629 
630  virtual double stampValue(const char *name, double default_value) = 0;
631  virtual std::string stampValue(
632  const char *name, const char *default_value) = 0;
633 
634  virtual void *_asVoidPointer() = 0;
635 
636  SWIGOUT(%newobject simulation;)
637  virtual HOM_DopSimulation *simulation() = 0;
638 
639  virtual std::vector<HOM_ElemPtr<HOM_Node> >
640  findNodesThatProcessedObject(HOM_DopObject &dop_object) = 0;
641 
642  virtual HOM_BinaryString _parmClipData(double start,
643  double end,
644  bool binary = true,
645  bool use_blosc_compression = true,
646  double sample_rate = 0,
647  bool scoped_only = false) = 0;
648 
649  SWIGOUT(%kwargs _setParmClipData;)
650  virtual void _setParmClipData(HOM_BinaryString data,
651  bool binary = true,
652  bool blosc_compressed = true,
653  double sample_rate = 0,
654  double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;
655 
656  virtual void _saveParmClip(std::string file_name,
657  double start,
658  double end,
659  double sample_rate = 0,
660  bool scoped_only = false) = 0;
661 
662  SWIGOUT(%kwargs _loadParmClip;)
663  virtual void _loadParmClip(std::string file_name,
664  double sample_rate = 0,
665  double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;
666 
667  virtual int __creationTime() = 0;
668  virtual int __modificationTime() = 0;
669 
670 #ifdef SWIG
671 %extend
672 {
673  // evalParm() and evalParmTuple() need to be special methods because
674  // their return types can vary.
675  InterpreterObject evalParm(const char *parm_path)
676  {
677  HOM_Parm *parm = self->parm(parm_path);
678 
679  if (!parm)
680  throw HOM_OperationFailed("Invalid parm name");
681 
682  InterpreterObject result = HOMevalParm(*parm);
683  delete parm;
684  return result;
685  }
686 
687  InterpreterObject evalParmTuple(const char *parm_path)
688  {
689  HOM_ParmTuple *parm_tuple = self->parmTuple(parm_path);
690 
691  if (!parm_tuple)
692  throw HOM_OperationFailed("Invalid parm tuple name");
693 
694  InterpreterObject result = HOMevalParmTuple(*parm_tuple);
695  delete parm_tuple;
696  return result;
697  }
698 
699  void addEventCallback(
700  const std::vector<HOM_EnumValue *> &event_types,
701  InterpreterObject callback)
702  { self->addOpaqueEventCallback(event_types, callback); }
703 
704  void addParmCallback(
705  InterpreterObject callback,
706  const std::vector<std::string> &names)
707  { self->addOpaqueParmCallback(callback,names); }
708 
709  void removeEventCallback(
710  const std::vector<HOM_EnumValue *> &event_types,
711  InterpreterObject callback)
712  { self->removeOpaqueEventCallback(event_types, callback); }
713 
714 
715  std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
716  eventCallbacks()
717  {
718  std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
719  opaque_callbacks(self->opaqueEventCallbacks());
720 
721  std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
722  callbacks;
723  for (int i=0; i< opaque_callbacks.size(); ++i)
724  callbacks.push_back(std::make_pair(
725  opaque_callbacks[i].first,
726  (InterpreterObject)opaque_callbacks[i].second));
727  return callbacks;
728  }
729 }
730 #endif
731 };
732 
733 #endif
detail::type
type
Definition: core.h:977
HOM_DESTRUCT_OBJECT
#define HOM_DESTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1238
HOM_Node::saveCodeToFile
void saveCodeToFile(const char *file_name, bool skip_header=false, const char *context_name=NULL)
Definition: HOM_Node.h:530
HOM_NodeType
Definition: HOM_NodeType.h:32
GT_Names::time
GT_API const UT_StringHolder time
start
GLuint start
Definition: glcorearb.h:474
HOM_Node::HOM_Node
HOM_Node()
Definition: HOM_Node.h:46
Filesystem::rename
OIIO_API bool rename(string_view from, string_view to, std::string &err)
binary
const GLuint GLenum const void * binary
Definition: glcorearb.h:1923
input
GLenum GLenum GLenum input
Definition: glew.h:14162
HOM_NodeTypeCategory
Definition: HOM_NodeTypeCategory.h:27
SWIGOUT
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
CL_Clip::isTimeDependent
int isTimeDependent() const
HOM_NetworkMovableItem
Definition: HOM_NetworkMovableItem.h:25
HOM_NetworkDot
Definition: HOM_NetworkDot.h:21
HOM_BinaryString
Definition: HOM_BinaryString.h:22
Vt_WrapArray::__repr__
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:353
HOM_NetworkBox
Definition: HOM_NetworkBox.h:25
name
GLuint const GLchar * name
Definition: glcorearb.h:785
HOM_Node::saveToCompiledVexFile
void saveToCompiledVexFile(const char *file_name, const char *context_name=NULL)
Definition: HOM_Node.h:539
HOM_Parm
Definition: HOM_Parm.h:30
HOM_API.h
HOM_HDAModule
Definition: HOM_HDAModule.h:23
HOM_Vector2
Definition: HOM_Vector2.h:24
HOM_Node::HOM_Node
HOM_Node(const HOM_Node &node)
Definition: HOM_Node.h:49
result
GLuint64EXT * result
Definition: glew.h:14311
type
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
simd::any
bool any(const vbool4 &v)
Definition: simd.h:3446
HOM_API
#define HOM_API
Definition: HOM_API.h:13
HOM_PtrOrNull.h
HOM_IndirectInput
Definition: HOM_IndirectInput.h:20
end
GLuint GLuint end
Definition: glcorearb.h:474
HOM_CONSTRUCT_OBJECT
#define HOM_CONSTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1237
string
GLsizei const GLchar *const * string
Definition: glcorearb.h:813
HOM_Node
Definition: HOM_Node.h:43
openvdb::OPENVDB_VERSION_NAME::math::Mat3::operator!=
bool operator!=(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Inequality operator, does exact floating point comparisons.
Definition: Mat3.h:570
HOM_DopObject
Definition: HOM_DopObject.h:19
HOM_MIN_NEGATIVE_DOUBLE
#define HOM_MIN_NEGATIVE_DOUBLE
Definition: HOM_Defines.h:46
filter
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glcorearb.h:1296
HOM_Node::hm
virtual HOM_HDAModule * hm()
Definition: HOM_Node.h:281
names
GLuint const GLuint * names
Definition: glew.h:2695
HOM_Node::~HOM_Node
~HOM_Node() override
Definition: HOM_Node.h:52
HOM_ParmTuple
Definition: HOM_ParmTuple.h:26
HOM_EnumModules.h
HOM_ParmTemplateGroup
Definition: HOM_ParmTemplateGroup.h:25
HOM_HDAViewerHandleModule
Definition: HOM_HDAViewerHandleModule.h:23
HOM_NetworkMovableItem.h
HOM_NodeGroup
Definition: HOM_NodeGroup.h:22
HOM_NodeInfoTree
Definition: HOM_NodeInfoTree.h:21
GT_Names::version
GT_API const UT_StringHolder version
HOM_NodeConnection
Definition: HOM_NodeConnection.h:25
debug
OIIO_API void debug(string_view str)
pattern
GLubyte * pattern
Definition: glew.h:5741
data
GLboolean * data
Definition: glcorearb.h:130
HOM_ElemPtr
Definition: HOM_ElemPtr.h:44
HOM_DopSimulation
Definition: HOM_DopSimulation.h:31
HOM_SubnetIndirectInput
Definition: HOM_SubnetIndirectInput.h:20
PY_OpaqueObject.h
HOM_StickyNote
Definition: HOM_StickyNote.h:23
value
GLsizei const GLfloat * value
Definition: glcorearb.h:823
HOM_EnumValue
Definition: HOM_EnumValue.h:23
HOM_HDAViewerStateModule
Definition: HOM_HDAViewerStateModule.h:23
CL_Clip
Definition: CL_Clip.h:42
HOM_BinaryString.h
HOM_IterableList.h
openvdb::OPENVDB_VERSION_NAME::math::Mat3::operator==
bool operator==(const Mat3< T0 > &m0, const Mat3< T1 > &m1)
Equality operator, does exact floating point comparisons.
Definition: Mat3.h:556
HOM_PtrOrNull
Definition: HOM_PtrOrNull.h:26
HOM_ParmTemplate
Definition: HOM_ParmTemplate.h:24