HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
HOM_OpNode.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_OpNode_h__
10 #define __HOM_OpNode_h__
11 
12 #include "HOM_API.h"
13 #include "HOM_Node.h"
14 
15 SWIGOUT(%rename(OpNode) HOM_OpNode;)
16 
17 class HOM_API HOM_OpNode : public HOM_Node
18 {
19 public:
21  : HOM_Node()
22  { HOM_CONSTRUCT_OBJECT(this) }
23  HOM_OpNode(const HOM_OpNode &node)
24  : HOM_Node(node)
26  { HOM_CONSTRUCT_OBJECT(this) }
27  ~HOM_OpNode() override
28  { HOM_DESTRUCT_OBJECT(this) }
29 
30  virtual std::vector<std::string> _getArgumentAutoComplete(
31  const char *method_name, const char *arguments,
32  bool meta_info_only = false) = 0;
33 
34  int __hash__() override = 0;
35  std::string __repr__() override = 0;
36 
37  // We need a quick way to get the OP_OpTypeId from C++ code so we know
38  // which subclass of HOM_Node we should cast to, so that's why
39  // opTypeIdAsInt() exists.
40  SWIGOUT(%ignore opTypeIdAsInt;)
41  virtual int opTypeIdAsInt() = 0;
42  // Further, we need a quick way to get the OBJ_OBJECT_TYPE from C++ code
43  // so we know which subclass of HOM_ObjNode we should cast to.
44  // That's why objTypeAsInt() exists.
45  SWIGOUT(%ignore objTypeAsInt;)
46  virtual int objTypeAsInt() = 0;
47 
48  virtual std::string creatorState() = 0;
49  virtual void setCreatorState(const char *state) = 0;
50 
51  virtual bool isBuiltExplicitly() = 0;
52  virtual void setBuiltExplicitly(bool built_explicitly) = 0;
53 
54  virtual HOM_EnumValue *expressionLanguage() = 0;
55  virtual void setExpressionLanguage(HOM_EnumValue &language) = 0;
56 
57  SWIGOUT(%newobject parm;)
58  virtual HOM_Parm *parm(const char* parm_path) = 0;
59 
60  SWIGOUT(%newobject parmTuple;)
61  virtual HOM_ParmTuple *parmTuple(const char* parm_path) = 0;
62 
63  SWIGOUT(%kwargs globParms;)
64  virtual std::vector<HOM_ElemPtr<HOM_Parm> > globParms(
65  const char *pattern, bool ignore_case=false,
66  bool search_label=false,
67  bool single_pattern=false) = 0;
68 
69  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parms() = 0;
70 
71  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsReferencingThis() = 0;
72 
73  virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuples() = 0;
74 
75  virtual std::vector<HOM_ElemPtr<HOM_Parm> > spareParms() = 0;
76  virtual void removeSpareParms() = 0;
77 
78  virtual void syncNodeVersionIfNeeded(const std::string &from_version) = 0;
79 
80  SWIGOUT(%kwargs setParmTemplateGroup;)
81  virtual void setParmTemplateGroup(
82  HOM_ParmTemplateGroup &parm_template_group,
83  bool rename_conflicting_parms=false) = 0;
84 
85  virtual std::vector<HOM_ElemPtr<HOM_ParmTuple> > parmTuplesInFolder(
86  const std::vector<std::string> &folder_names) = 0;
87 
88  virtual std::vector<HOM_ElemPtr<HOM_Parm> > parmsInFolder(
89  const std::vector<std::string> &folder_names) = 0;
90 
91  SWIGOUT(%newobject parmTemplateGroup;)
92  virtual HOM_ParmTemplateGroup *parmTemplateGroup() = 0;
93 
94  virtual std::vector<std::string> localVariables() = 0;
95  virtual std::vector<std::string> localAttributes() = 0;
96 
97  SWIGOUT(%kwargs reorderChild;)
98  virtual void reorderChild(int src, int dest) = 0;
99 
100  // Dependency information.
101  SWIGOUT(%kwargs references;)
102  virtual std::vector<HOM_ElemPtr<HOM_Node> >
103  references(bool include_children=true) = 0;
104  SWIGOUT(%kwargs dependents;)
105  virtual std::vector<HOM_ElemPtr<HOM_Node> >
106  dependents(bool include_children=true) = 0;
107  SWIGOUT(%kwargs fileReferences;)
108  SWIGOUT(%newobject fileReferences;)
109  virtual std::vector<std::pair<HOM_ElemPtr<HOM_Parm>, std::string> >
110  fileReferences(bool recurse = true,
111  const char* project_dir_variable = "HIP",
112  bool include_all_refs = true) = 0;
113  virtual bool isTimeDependent(bool for_last_cook=false) = 0;
114 
115  // If propagate==true, unlock will be propagated to ancestors
116  SWIGOUT(%kwargs allowEditingOfContents;)
117  virtual void allowEditingOfContents(bool propagate=false) = 0;
118  virtual void matchCurrentDefinition() = 0;
119  virtual bool matchesCurrentDefinition() = 0;
120 
121  virtual void syncDelayedDefinition() = 0;
122  virtual bool isDelayedDefinition() = 0;
123 
124  SWIGOUT(%kwargs parmAliases;)
125  virtual std::map<HOM_ElemPtr<HOM_Parm>, std::string>
126  parmAliases(bool recurse=false) = 0;
127 
128  virtual void clearParmAliases() = 0;
129 
130  SWIGOUT(%kwargs createCompiledDigitalAsset);
131  virtual void createCompiledDigitalAsset(const char *name=NULL,
132  const char *hda_file_name=NULL, const char *description=NULL) = 0;
133  virtual bool isInsideLockedHDA() = 0;
134  virtual bool isEditableInsideLockedHDA() = 0;
135  virtual bool isLockedHDA() = 0;
136  virtual bool isCompiled() = 0;
137  virtual bool isMaterialManager() = 0;
138 
139  virtual std::string outputLabel(int output_index) = 0;
140 
141  virtual int outputForViewFlag() = 0;
142  virtual void setOutputForViewFlag(int output) = 0;
143  SWIGOUT(%newobject hdaModule;)
144  virtual HOM_HDAModule *hdaModule() = 0;
145  SWIGOUT(%newobject hdaViewerStateModule;)
146  virtual HOM_HDAViewerStateModule *hdaViewerStateModule() = 0;
147  SWIGOUT(%newobject hdaViewerHandleModule;)
148  virtual HOM_HDAViewerHandleModule *hdaViewerHandleModule() = 0;
149  // hm is an alias for hdaModule.
150  SWIGOUT(%newobject hm;)
151  virtual HOM_HDAModule *hm()
152  { return hdaModule(); }
153  SWIGOUT(%kwargs createDigitalAsset);
154  SWIGOUT(%newobject createDigitalAsset;)
155  virtual HOM_Node *createDigitalAsset(const char *name=NULL,
156  const char *hda_file_name=NULL, const char *description=NULL,
157  int min_num_inputs=0, int max_num_inputs=0,
158  bool compress_contents=false, const char *comment=NULL,
159  const char *version=NULL, bool save_as_embedded=false,
160  bool ignore_external_references=false,
161  bool compile_asset = false,
162  bool change_node_type = true,
163  bool create_backup = true,
164  const char *install_path=NULL) = 0;
165 
166  SWIGOUT(%kwargs changeNodeType);
167  SWIGOUT(%newobject changeNodeType;)
168  virtual HOM_Node *changeNodeType(const char *new_node_type,
169  bool keep_name=true, bool keep_parms=true,
170  bool keep_network_contents=true,
171  bool force_change_on_node_type_match=false) = 0;
172 
173 
174  // TOPs work item navigation, these are here
175  // so both TopNode and SopNode (for sop top networks)
176  // can call them
177  virtual void selectNextVisibleWorkItem() = 0;
178  virtual void selectPreviousVisibleWorkItem() = 0;
179  virtual void deselectWorkItem() = 0;
180  virtual void setCurrentTOPPage(int page) = 0;
181 
182  virtual bool canGenerateCookCode(bool check_parent=false,
183  bool check_auto_shader=true) = 0;
184  SWIGOUT(%newobject cookCodeGeneratorNode;)
185  virtual HOM_Node *cookCodeGeneratorNode() = 0;
186  virtual std::string cookCodeLanguage() = 0;
187  virtual bool supportsMultiCookCodeContexts() = 0;
188 
189  SWIGOUT(%kwargs saveCookCodeToFile;)
190  virtual void saveCookCodeToFile(
191  const char *file_name, bool skip_header=false,
192  const char *context_name = NULL) = 0;
193 
194  // This method is deprecated.
195  void saveCodeToFile(const char *file_name, bool skip_header=false,
196  const char *context_name = NULL)
197  { saveCookCodeToFile(file_name, skip_header, context_name); }
198 
199  virtual void saveCompiledCookCodeToFile(const char *file_name,
200  const char *context_name = NULL) = 0;
201 
202  // This method is deprecated.
203  void saveToCompiledVexFile(const char *file_name,
204  const char *context_name = NULL)
205  { saveCompiledCookCodeToFile(file_name, context_name); }
206 
207  SWIGOUT(%kwargs cook;)
208  virtual void cook(
209  bool force = false,
210  const std::vector<double> frame_range = std::vector<double>()) = 0;
211 
212  SWIGOUT(%kwargs cookNoInterruptInternal;)
213  virtual void _cookNoInterruptInternal(
214  bool force = false,
215  const std::vector<double> frame_range = std::vector<double>()) = 0;
216 
217  /// Determine if this node to cook at the current evaluation time
218  virtual bool needsToCook() = 0;
219  /// Determine if this node to cook at the given time
220  virtual bool needsToCook(double time) = 0;
221 
222  virtual void invalidateOutput() = 0;
223 
224  virtual int cookCount() = 0;
225 
226  virtual std::vector<HOM_ElemPtr<HOM_Node> > cookPathNodes() = 0;
227 
228  SWIGOUT(%kwargs infoTree;)
229  virtual HOM_NodeInfoTree infoTree(
230  bool verbose = false,
231  bool debug = false,
232  int output_index = 0,
233  bool force_cook = false) = 0;
234 
235  virtual std::map<std::string, hboost::any> infoData() = 0;
236 
237  virtual void updateParmStates() = 0;
238 
239  virtual void runInitScripts() = 0;
240  virtual std::string deleteScript() = 0;
241  virtual void setDeleteScript(const std::string &script_text,
242  HOM_EnumValue &language = HOM_scriptLanguage::Python) = 0;
243 
244  SWIGOUT(%newobject addNodeGroup;)
245  virtual HOM_NodeGroup *addNodeGroup(const char *name = NULL) = 0;
246 
247  virtual std::vector<HOM_ElemPtr<HOM_NodeGroup> > nodeGroups() = 0;
248 
249  SWIGOUT(%newobject nodeGroup;)
250  virtual HOM_NodeGroup *nodeGroup(const char *name) = 0;
251 
252  virtual std::string motionEffectsNetworkPath() = 0;
253  SWIGOUT(%newobject findOrCreateMotionEffectsNetwork;)
254  virtual HOM_Node *findOrCreateMotionEffectsNetwork(bool create=true) = 0;
255  virtual void createOrMoveVisualizer(int output_index) = 0;
256 
257  SWIGOUT(%kwargs saveItemsToFile;)
258  virtual void saveItemsToFile(
259  const std::vector<HOM_NetworkMovableItem *> &items,
260  const char *file_name,
261  bool save_hda_fallbacks = false) = 0;
262  SWIGOUT(%kwargs loadItemsFromFile;)
263  virtual void loadItemsFromFile(
264  const char *file_name, bool ignore_load_warnings=false) = 0;
265 
266  SWIGOUT(%ignore addOpaqueEventCallback;)
267  virtual void addOpaqueEventCallback(
268  const std::vector<HOM_EnumValue *> &event_types,
269  void *py_callback) = 0;
270  SWIGOUT(%ignore addOpaqueParmCallback;)
271  virtual void addOpaqueParmCallback(
272  void *py_callback,
273  const std::vector<std::string> &names) = 0;
274  SWIGOUT(%ignore removeOpaqueEventCallback;)
275  virtual void removeOpaqueEventCallback(
276  const std::vector<HOM_EnumValue *> &event_types,
277  void *py_callback) = 0;
278  virtual void removeAllEventCallbacks() = 0;
279  SWIGOUT(%ignore opaqueEventCallbacks;)
280  virtual std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
281  opaqueEventCallbacks() = 0;
282 
283  SWIGOUT(%ignore getUniqueId;)
284  virtual int getUniqueId() = 0;
285 
286  virtual double stampValue(const char *name, double default_value) = 0;
287  virtual std::string stampValue(
288  const char *name, const char *default_value) = 0;
289 
290  // asCode methods:
291  SWIGOUT(%kwargs asCode;)
292  virtual std::string asCode(bool brief=false,
293  bool recurse=false,
294  bool save_channels_only=false,
295  bool save_creation_commands=true,
296  bool save_keys_in_frames=false,
297  bool save_outgoing_wires=false,
298  bool save_parm_values_only=false,
299  bool save_spare_parms=true,
300  bool save_box_membership=true,
301  const char *function_name=NULL) = 0;
302 
303  // Data Block methods (like user data, but bigger blobs with associated
304  // data types).
305  virtual std::vector<std::string> dataBlockKeys(
306  const char *blocktype = nullptr) = 0;
307  virtual std::string dataBlockType(const char *key) = 0;
308  virtual HOM_BinaryString dataBlock(const char *key) = 0;
309  SWIGOUT(%kwargs setDataBlock;)
310  virtual void setDataBlock(const char *key, HOM_BinaryString data,
311  const char *block_type = nullptr) = 0;
312  virtual void removeDataBlock(const char *key) = 0;
313 
314  // Cached user data methods:
315  SWIGOUT(%ignore setOpaqueCachedUserData;)
316  virtual void setOpaqueCachedUserData(
317  const char *name, void *opaque_py_object) = 0;
318  SWIGOUT(%ignore opaqueCachedUserData;)
319  virtual void *opaqueCachedUserData(const char *name) = 0;
320  virtual void destroyCachedUserData(
321  const char *name, bool must_exist=true) = 0;
322  virtual void clearCachedUserDataDict() = 0;
323  virtual std::map<std::string, PY_OpaqueObject> cachedUserDataDict() = 0;
324 
325 #ifdef SWIG
326 %extend
327 {
328  void setCachedUserData(const char *name, InterpreterObject value)
329  { return self->setOpaqueCachedUserData(name, value); }
330 
331  InterpreterObject cachedUserData(const char *name)
332  { return HOMincRef((InterpreterObject)self->opaqueCachedUserData(name)); }
333 }
334 #endif
335 
336  SWIGOUT(%newobject simulation;)
337  virtual HOM_DopSimulation *simulation() = 0;
338 
339  virtual std::vector<HOM_ElemPtr<HOM_Node> >
340  findNodesThatProcessedObject(HOM_DopObject &dop_object) = 0;
341 
342  virtual HOM_BinaryString _parmClipData(double start,
343  double end,
344  bool binary = true,
345  bool use_blosc_compression = true,
346  double sample_rate = 0,
347  bool scoped_only = false) = 0;
348 
349  SWIGOUT(%kwargs _setParmClipData;)
350  virtual void _setParmClipData(HOM_BinaryString data,
351  bool binary = true,
352  bool blosc_compressed = true,
353  double sample_rate = 0,
354  double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;
355 
356  virtual void _saveParmClip(std::string file_name,
357  double start,
358  double end,
359  double sample_rate = 0,
360  bool scoped_only = false) = 0;
361 
362  SWIGOUT(%kwargs _loadParmClip;)
363  virtual void _loadParmClip(std::string file_name,
364  double sample_rate = 0,
365  double start = HOM_MIN_NEGATIVE_DOUBLE) = 0;
366 
367  virtual int __creationTime() = 0;
368  virtual int __modificationTime() = 0;
369  virtual void *_asVoidPointer() = 0;
370 
371  SWIGOUT(%kwargs addError;)
372  virtual void addError(const char *message = 0,
374  SWIGOUT(%kwargs addWarning;)
375  virtual void addWarning(const char *message = 0) = 0;
376  SWIGOUT(%kwargs addMessage;)
377  virtual void addMessage(const char *message = 0) = 0;
378 
379  virtual float lastCookTime() = 0;
380  virtual std::map<std::string, hboost::any> lastCookContextOptions(
381  bool only_used_options = false) = 0;
382 
383 #ifdef SWIG
384 %extend
385 {
386  // evalParm() and evalParmTuple() need to be special methods because
387  // their return types can vary.
388  InterpreterObject evalParm(const char *parm_path)
389  {
390  HOM_Parm *parm = self->parm(parm_path);
391 
392  if (!parm)
393  throw HOM_OperationFailed("Invalid parm name");
394 
395  InterpreterObject result = HOMevalParm(*parm);
396  delete parm;
397  return result;
398  }
399 
400  InterpreterObject evalParmTuple(const char *parm_path)
401  {
402  HOM_ParmTuple *parm_tuple = self->parmTuple(parm_path);
403 
404  if (!parm_tuple)
405  throw HOM_OperationFailed("Invalid parm tuple name");
406 
407  InterpreterObject result = HOMevalParmTuple(*parm_tuple);
408  delete parm_tuple;
409  return result;
410  }
411 
412  void addEventCallback(
413  const std::vector<HOM_EnumValue *> &event_types,
414  InterpreterObject callback)
415  { self->addOpaqueEventCallback(event_types, callback); }
416 
417  void addParmCallback(
418  InterpreterObject callback,
419  const std::vector<std::string> &names)
420  { self->addOpaqueParmCallback(callback,names); }
421 
422  void removeEventCallback(
423  const std::vector<HOM_EnumValue *> &event_types,
424  InterpreterObject callback)
425  { self->removeOpaqueEventCallback(event_types, callback); }
426 
427 
428  std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
429  eventCallbacks()
430  {
431  std::vector<std::pair<std::vector<HOM_EnumValue *>, void *> >
432  opaque_callbacks(self->opaqueEventCallbacks());
433 
434  std::vector<std::pair<std::vector<HOM_EnumValue *>, InterpreterObject> >
435  callbacks;
436  for (int i=0; i< opaque_callbacks.size(); ++i)
437  callbacks.push_back(std::make_pair(
438  opaque_callbacks[i].first,
439  (InterpreterObject)opaque_callbacks[i].second));
440  return callbacks;
441  }
442 }
443 #endif
444 };
445 
446 #endif
GLuint GLsizei const GLchar * message
Definition: glcorearb.h:2543
std::string ignore_case(std::string item)
Helper function to allow ignore_case to be passed to IsMember or Transform.
Definition: CLI11.h:3456
#define HOM_DESTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1343
GT_API const UT_StringHolder time
GLuint start
Definition: glcorearb.h:475
GLsizei const GLfloat * value
Definition: glcorearb.h:824
const GLuint GLenum const void * binary
Definition: glcorearb.h:1924
#define SWIGOUT(x)
Definition: HOM_Defines.h:24
string __repr__(VtArray< T > const &self)
Definition: wrapArray.h:312
**But if you need a result
Definition: thread.h:622
void saveCodeToFile(const char *file_name, bool skip_header=false, const char *context_name=NULL)
Definition: HOM_OpNode.h:195
#define HOM_API
Definition: HOM_API.h:13
void ignore(T const &) VULKAN_HPP_NOEXCEPT
Definition: vulkan.hpp:6508
GLuint GLuint end
Definition: glcorearb.h:475
#define HOM_CONSTRUCT_OBJECT(pointer)
Definition: HOM_Module.h:1342
void * _asVoidPointer()
Definition: HOM_Vector3.h:148
#define HOM_MIN_NEGATIVE_DOUBLE
Definition: HOM_Defines.h:50
GLenum GLenum severity
Definition: glcorearb.h:2539
GLuint const GLchar * name
Definition: glcorearb.h:786
GLushort pattern
Definition: glad.h:2583
GT_API const UT_StringHolder version
OIIO_API void debug(string_view str)
GA_API const UT_StringHolder parms
HOM_OpNode(const HOM_OpNode &node)
Definition: HOM_OpNode.h:23
Error
Definition: oidn.hpp:577
SIM_API const UT_StringHolder force
OIIO_UTIL_API bool rename(string_view from, string_view to, std::string &err)
virtual HOM_HDAModule * hm()
Definition: HOM_OpNode.h:151
void saveToCompiledVexFile(const char *file_name, const char *context_name=NULL)
Definition: HOM_OpNode.h:203
state
Definition: core.h:2289
~HOM_OpNode() override
Definition: HOM_OpNode.h:27
Definition: format.h:1821
int __hash__()
GLenum src
Definition: glcorearb.h:1793