HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
LOP_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  * NAME: LOP Library (C++)
7  *
8  * COMMENTS: The base class for all Lighting Operators
9  *
10  */
11 
12 #ifndef __LOP_Node_h__
13 #define __LOP_Node_h__
14 
15 #include "LOP_API.h"
16 #include "LOP_Error.h"
17 #include "LOP_LayerCheckpoints.h"
18 #include <OP/OP_Network.h>
19 #include <HUSD/HUSD_DataHandle.h>
20 #include <HUSD/HUSD_PathSet.h>
21 #include <HUSD/HUSD_TimeCode.h>
22 #include <HUSD/HUSD_Xform.h>
23 #include <GU/GU_DetailHandle.h>
25 #include <UT/UT_Ramp.h>
26 
27 class LOP_Network;
30 class HUSD_FindPrims;
31 class HUSD_FindProps;
32 class HUSD_Info;
33 class PRM_Template;
34 class PRM_Name;
35 class UT_ArrayStringSet;
36 class UT_StringSet;
37 
38 extern "C" {
40 };
41 
42 #define LOP_DEBUG_FLAG 'D'
43 
48 };
49 
53 };
54 
59 };
60 
62 {
63 public:
66  bool myCreateReplacement = false;
67  bool myReplaceSublayersOnly = false;
68  bool myClearSource = false;
69  bool myCreateNewSublayer = false;
72 };
73 
75 {
76 public:
78  : myFrame(1.0),
79  myTime(0.0),
80  myRampBasisIsArray(false),
83  myValueLength(1),
84  myValueIsTimeDep(false),
85  myValueIsOrdered(false),
86  myIsCustom(true), // USD assumes custom attribs
87  myExpandCollection(true),
88  myClearAttrib(false),
91  { }
92 
107  UT_StringHolder myConnection; // path to the source attrib
110  int myValueInt[16];
120 
121  // Data members specific to authoring a collection from parms. This
122  // data is used if myValueType == HUSD_PROPERTY_VALUETYPE_COLLECTION.
131 };
133 
135 {
136 public:
137  // Standard OP_Network stuff:
138  static const char *theChildTableName;
139  const char *getChildType() const override;
140  const char *getOpType() const override;
141 
142  OP_OpTypeId getChildTypeID() const override;
143  OP_OpTypeId getOpTypeID() const override;
144  OP_DataType getCookedDataType() const override;
145 
146  static void buildOperatorTable(OP_OperatorTable &table);
147  static OP_Operator *getManagementOperator();
148  static void initializeExpressions();
149 
150  // Get a LOP node from the provided path. If the path is a LOP node path,
151  // return that LOP node. If it is a LOP network path, return the path to
152  // that LOP network's viewer node.
153  static LOP_Node *getLopNodeFromLopOrNetworkPath(const char *path,
154  bool default_to_stage = true);
155 
156  // Local variables that can be used by nodes which allow user-specifiable
157  // names on inputs (such as merge into and add variant).
158  static CH_LocalVariable theInputNameLocalVariables[];
159 
160  void opChanged(OP_EventType reason, void *data=0) override;
161  void onCreated() override;
162 
163  fpreal getW() const override;
164  fpreal getH() const override;
165 
166  // Gets/sets the value of the debug flag on this node.
167  bool getDebug() const override;
168  bool setDebug(bool state) override;
169  void setFlag(char flag, int8 val) override;
170  bool getNestedDebug() const;
171 
172  // Overrides the current node pointer method to ensure that we always
173  // find a current node when the old current node is deleted, even in the
174  // absence of a display node.
175  OP_Node *getCurrentNodePtr() override;
176  // Overrides the display node pointer method because a LOP node with LOP
177  // children doesn't need to have a display node, and will return the
178  // display node of the parent LOP network if it doesn't have its own.
179  OP_Node *getDisplayNodePtr() override;
180  void childFlagChange(OP_Node *nodeptr) override;
181  virtual LOP_Node *getViewerLop();
182 
183  // Gets the output child node corresponding to the specified output index.
184  LOP_Node *getOutputLop(int outputidx) const;
185 
186  // Override the function that determines whether this node should be
187  // drawn in the network editor with a "bypass" look. LOPs have an optional
188  // "bypass" spare parameter that makes the node act like it is bypassed,
189  // so it should also be drawn like it's bypassed.
190  bool getUseBypassLook(
191  const OP_EditorContext &ctx) const override;
192 
193  // Cook this node and return a data handle for the resulting stage.
194  const HUSD_DataHandle &getCookedDataHandle(OP_Context &context,
195  int outidx = 0,
196  bool use_last_cook_context_options = false,
197  const UT_StringSet *protect_options = nullptr);
198  // Cook this node and return a data handle for the resulting stage. If
199  // the cook leaves this node in an error state, go to this node's first
200  // connected input, and try to return the cooked data handle for that
201  // node, and so on. This method is useful for the scene graph tree and
202  // similar panels, where it's much more useful to show something than
203  // nothing in the case of an error. Returns the data handle and a
204  // pointer to the node whose data is actually returned.
205  const HUSD_DataHandle &getCookedDataHandleBypassingErrors(
206  LOP_Node *&owner_node,
207  int &owner_outidx,
208  OP_Context &context,
209  int outidx = 0,
210  bool use_last_cook_context_options = false,
211  const UT_StringSet *protect_options = nullptr);
212  // Return true if this node was the most recent node to create a lock
213  // on the stage we may be sharing with many other nodes.
214  bool isMostRecentStageLock() const;
215 
216  // Get the badge clor we should use for this LOP node do indicate which
217  // active layer is modified by this node.
218  bool hasLayerColorIndex(int &clridx) const;
219 
220  // Return true if this node is in an Edit Layer Block, otherwise false.
221  bool inEditLayerBlock() const;
222 
223  // Override this for nodes that want to allow python code to edit their
224  // stage or active layer directly.
225  virtual HUSD_PythonConverter *getEditableObject(LOP_EditableObject obj);
226 
227  // Create a new HUSD_LoadMasks object using parameters on the creator
228  // LOP Network to set variant selection fallback values.
229  HUSD_LoadMasksPtr createNewLoadMasks();
230 
231  // Evaluate a simplified adhoc collection parm and use it to fill in an
232  // HUSD_FindPrims object.
233  static bool getSimplifiedCollection(OP_Node *node,
234  const UT_StringRef &primpattern,
235  HUSD_FindPrims &findprims);
236  // Evaluate a simplified adhoc collection parm and use it to fill in an
237  // HUSD_FindProps object.
238  static bool getSimplifiedCollection(OP_Node *node,
239  const UT_StringRef &primpattern,
240  const UT_StringRef &proppattern,
241  HUSD_FindProps &findprops);
242  // Evaluate a pattern string using an HUSD_FindPrims against a LOP node's
243  // editableDataHandle, and return an array of matching paths. Isolates
244  // the locking of the stage to this function.
245  static bool getPathsFromPattern(LOP_Node &lop,
246  const UT_StringRef &pattern,
247  UT_StringArray &paths,
248  bool allow_missing_explicit_prims = false);
249  // Tests if the provided primitive is editable. Adds the result to the
250  // provided map so the next call with the same path can return the cached
251  // result immediately. The first time each non-editable prim is found,
252  // a warning is added to this node.
253  bool isPrimitiveEditable(
254  UT_StringMap<bool> alloweditmap,
255  const HUSD_Info &info,
256  const UT_StringHolder &path,
257  bool ignoreeditableflag,
258  LOP_ErrorCodes non_editable_error_code =
260 
261  // Return the number of layers in our data handle.
262  int layerCount() const;
263 
264  // Track the set of primitives modified by the most recent cook of
265  // this node.
266  const HUSD_PathSet &lastModifiedPrims() const;
267  void setLastModifiedPrims(const UT_StringRef &path,
268  bool add_to_existing = false);
269  void setLastModifiedPrims(const UT_StringArray &paths,
270  bool add_to_existing = false);
271  void setLastModifiedPrims(const UT_ArrayStringSet &paths,
272  bool add_to_existing = false);
273  void setLastModifiedPrims(const HUSD_FindPrims &findprims,
274  bool add_to_existing = false);
275  void setLastModifiedPrims(const HUSD_PathSet &paths,
276  bool add_to_existing = false);
277  void setLastModifiedPrimsWithPathExpression(
278  HUSD_AutoAnyLock &lock,
279  const UT_StringRef &path_expr,
280  bool add_to_existing = false);
281  void clearLastModifiedPrims();
282 
283  // Tests if this node has an active layer that is large enough that we
284  // want output nodes to always start a new active layer. The default
285  // implementation looks at the number of lastModifiedPrims. This method
286  // is const and should never trigger a cook - it should always look at
287  // data from the most recent cook (and return false if the node has
288  // never been cooked).
289  virtual bool hasLargeActiveLayer() const;
290 
291  // For a new stage being authored by this node, these methods allow the
292  // node to control the asset path or url/string pairs used to configure
293  // the stage's asset resolver context. Individual node types can provide
294  // custom implementations.
295  virtual bool getResolverContextAssetPath(UT_String &assetpath);
296  virtual bool getResolverContextStrings(
297  UT_StringMap<UT_StringHolder> &resolverstrings);
298 
299  // Code for tracking convex hulls around context option "blocks" in the
300  // network editor.
301  virtual bool showConvexHull() const
302  { return false; }
303  virtual int contextOptionsStackEffect(int input) const
304  { return 0; }
305  virtual void findEnclosedItems(OP_EnclosedItems &items) const;
306 
307  // Evaluate local variables common to multiple LOP node types.
308  bool evalVariableValue(fpreal &val, int var_id,
309  int thread) override;
310  bool evalVariableValue(UT_String &val, int var_id,
311  int thread) override;
313  const char *name) override;
315  UT_StringArray &names) override;
316 
318  { return myLastCookActivation; }
319  HUSD_TimeCode getTimeCode(const OP_Context &context,
320  bool timedep) const;
321  HUSD_LoadMasksPtr getLastCookLoadMasks(int outidx = 0);
322 
323  // Public functions for adding warnings and errors, so that utility
324  // methods in LOP_PRMShared and elsewhere can add errors directly to
325  // LOP nodes.
326  void addSystemError(const char *msg = 0)
327  { getLockedErrorManager()->systemError(msg); }
328  void addError(int code, const char *msg = 0)
330  addError(LOP_OPTYPE_NAME, code, msg); }
331  void addWarning(int code, const char *msg = 0)
333  addWarning(LOP_OPTYPE_NAME, code, msg); }
334  void addMessage(int code, const char *msg = 0)
336  addMessage(LOP_OPTYPE_NAME, code, msg); }
337 
338  const char *inputLabel(OP_InputIdx idx) const override;
339  const char *outputLabel(OP_OutputIdx idx) const override;
340 
342  const OP_NodeInfoTreeParms &parms) override;
343 
344  // Guide geometry for display in the viewport, but which does not appear
345  // in the USD stage anywhere.
346  virtual int getNumGuides() const;
347  virtual const char *getGuideColorName(int idx) const;
348  GU_DetailHandle cookGuide(int idx, OP_Context &context);
349 
350  // For transforming between LOP and OBJ spaces.
351  int getRelativeTransform(OP_Node &to,
352  UT_Matrix4 &xform,
353  OP_Context &context) override;
354  int getRelativeTransform(OP_Node &to,
355  UT_DMatrix4 &xform,
356  OP_Context &context) override;
357 
358  // Extracting camera info directly from a LOP stage.
359  bool getCameraInfo(const UT_StringRef &camid,
360  const OP_Context &context,
361  DEP_MicroNode *depnode,
362  UT_StringHolder &foundcamid,
363  UT_CameraParms &camparms) override;
365  const OP_Context &context,
366  bool get_inverse_xform,
367  DEP_MicroNode *depnode,
368  UT_DMatrix4 &xform) override;
369 
370  // Called on any parm that gets evaluated while in getAttributeParmSet.
371  virtual void handleParmEvaluatedForParmSet(PRM_Parm *parm);
372 
373  // For C++ nodes that want to support multiple outputs, override this
374  // method to return true. The output index will be supplied to the cook
375  // method as a context option.
376  virtual bool supportMultipleOutputsAsContextOption() const;
377 
378  // Returns the name of the context option into which we put the "output
379  // index" to cook for a node that returns true from
380  // supportMultipleOutputsAsContextOption.
381  static const UT_StringHolder &getOutputIndexContextOption();
382 
383 protected:
384  LOP_Node(OP_Network *parent, const char *name,
385  OP_Operator *entry);
386  ~LOP_Node() override;
387 
388  // Common cook method for all LOP nodes. Calls cookMyLop.
389  OP_ERROR cookMe(OP_Context &context) override;
390  // Specific cook method for each LOP node, must be overridden.
391  virtual OP_ERROR cookMyLop(OP_Context &context) = 0;
392  // Specific guide cook method for each LOP node.
393  virtual GU_DetailHandle cookMyGuide(int idx, OP_Context &context);
394  // Clears any cached data for this node. In the case of a LOP node, this
395  // means clearing our locked stage pointer from the GusdStageCache.
396  void clearCache() override;
397  // Makes our own data handle reference or copy the data handle of another
398  // node. Should be used to reference nodes that are not inputs to this
399  // node.
400  OP_ERROR cookReferenceNode(OP_Context &context,
401  LOP_Node *source_lop,
402  int outidx = 0,
403  bool copy_data_handle = false,
404  bool add_extra_input = true,
405  const HUSD_LoadMasksPtr &load_masks =
407  // Makes our own data handle reference or copy the data handle of one
408  // of our input nodes.
409  OP_ERROR cookReferenceInput(OP_Context &context,
410  int which_input = 0,
411  bool require_input = false,
412  bool copy_data_handle = false,
413  const HUSD_LoadMasksPtr &load_masks =
415  // Wrapper to call copyReferenceInput with the copy_data_handle
416  // parameter set to true.
417  OP_ERROR cookModifyInput(OP_Context &context,
418  int which_input = 0,
419  bool require_input = false,
420  const HUSD_LoadMasksPtr &load_masks =
422  // Makes our own data handle reference or copy the data handle of another
423  // node, but replace one layer in the source stage with another layer.
424  // Should be used to reference nodes that are not inputs to this
425  // node.
426  OP_ERROR cookReferenceNodeWithReplacement(OP_Context &context,
427  LOP_Node *source_lop,
428  const UT_StringRef &from_path_pattern,
429  const LOP_LayerReplacementInfo &replacement_info,
430  UT_StringSet &replaced_layers,
431  bool add_extra_input);
432  // Makes our own data handle reference or copy the data handle of one
433  // of our input nodes, but replace one layer in the source stage with
434  // another layer.
435  OP_ERROR cookReferenceInputWithReplacement(OP_Context &context,
436  const UT_StringRef &from_path_pattern,
437  const LOP_LayerReplacementInfo &replacement_info,
438  UT_StringSet &replaced_layers,
439  int which_input,
440  bool require_input);
441  // Access the data handle of one of our inputs, that must have been
442  // locked already to ensure the data is cooked for the current context.
443  const HUSD_DataHandle &lockedInputData(OP_Context &context,
444  int which_input);
445  // Access our own data handle for modification. Should only be called
446  // from within cookMyLop.
447  HUSD_DataHandle &editableDataHandle();
448 
449  // For subnet nodes, this method will return the contained node that
450  // corresponds to specified output connector index. For all other nodes
451  // with will return nullptr. This will trigger a call to syncDelayedOTL
452  // if outidx > 0.
453  LOP_Node *getNodeForSubnetOutput(int outidx);
454 
455  // For nodes with editable input names, this function evaluates all the
456  // input names, assigning any dependencies to the specified parameter.
457  OP_ERROR getInputStrings(const UT_StringRef &key_parm_name,
458  fpreal t,
459  UT_StringArray &input_names,
460  bool allow_empty_strings = false);
461 
462  // Functions for controlling checkpoints created during a cook operation.
463  void setClearCheckpointsOnInputChange(bool clear);
464  void createCheckpoint(const HUSD_AutoAnyLock &lock,
465  const UT_StringHolder &id);
466  void removeCheckpoint(const UT_StringRef &id);
467  void removeAllCheckpoints();
468 
469  // Functions for accessing existing checkpoitns during a cook operation.
470  void getAvailableCheckpoints(UT_StringArray &ids) const;
471  bool restoreCheckpoint(const HUSD_AutoLayerLock &layerlock,
472  const UT_StringRef &id);
473 
474  OP_ERROR bypassMe(OP_Context &context,
475  int &copied_input) override;
476  void deleteCookedData() override;
477  int saveCookedData(const char *, OP_Context &) override;
478  int saveCookedData(std::ostream &os, OP_Context &,
479  int binary = 0) override;
480  const char *getFileExtension(int bin) const override;
481 
482  // Specifically fills in the ramp attribute names from the spare tags on
483  // a parameter. Used by getAttributeParmSet, but can be called separately
484  // from that function for blocking attributes for a ramp parameter.
485  static void getRampAttributeNamesForParmSet(
486  const PRM_Template *tplate,
487  LOP_AttributeParmSet &pset);
488  // Populates a LOP_AttributeParmSet data structure from a parameter, using
489  // all the USD-specific information in the parameter's spare tags.
490  void getAttributeParmSet(OP_Node *node,
491  const PRM_Template *tplate,
492  LOP_AttributeParmSet &pset,
493  fpreal t);
494  // Applies any API schema mentioned in the LOP_AttributeParmSet. This
495  // method can be called in a change block before calling
496  // setAttributeFromParmSet for a bunch of LOP_AttributeParmSets.
497  // Applying the schemas first in a change block can greatly reduce the
498  // amount of recomposition done as a result of adding an API schema to
499  // a large number of primitives.
500  bool applySchemaFromParmSet(
501  HUSD_AutoWriteLock &writelock,
502  LOP_AttributeParmSet &pset,
503  UT_StringSet *failedapis = nullptr);
504  // Sets a USD attribute or relationship on a USD primitive based on the
505  // current value of a node parameter. Use getAttributeParmSet to populate
506  // the LOP_AttributeParmSet data structure from the parm first.
507  bool setAttributeFromParmSet(
508  HUSD_AutoWriteLock &writelock,
509  LOP_AttributeParmSet &pset,
510  fpreal t,
511  UT_StringSet *failedapis = nullptr);
512 
513  // Helps with convex hull generation by looking at the context option
514  // stack information implemented by the virtual contextOptionsStackEffect.
515  void encloseInputs(OP_EnclosedItems &items,
516  int stackdepth) const;
517 
518  // Map of attribute names to evaluator objects.
521 
522  // Helper class to determine whether nodes with multiple inputs will be
523  // composing stages with differing time-codes-per-second (TCPS) metadata.
524  //
525  // As of USD 20.08, if you reference/sublayer (i.e., compose) a 60tcps stage
526  // into a 24tcps stage (for example), any time sample data within will be
527  // automatically time-scaled (1.0 -> 0.4, ..., 60.0 -> 24.0, etc).
528  //
529  // If the data for the stage is driven by Houdini expressions/keyframes and
530  // not by cached time samples, this time-scaling is not applied, which might
531  // be unexpected for the user. This class can help warn them.
532  //
533  // Expected usage in `cookMyLop()`:
534  // - sometime after `cookModifyInput(context);`, instantiate a checker:
535  // `DifferingTimeCodesPerSecChecker tcpsChecker(this);`
536  // - whenever you first get your secondary inputs via
537  // `const HUSD_DataHandle &datahandle = lockedInputData(context, i);`,
538  // add this data handle to the checker:
539  // `tcpsChecker.addInput(datahandle, context);`
540  // - whenever you first get your primary input via
541  // `const HUSD_DataHandle &datahandle = editableDataHandle();`
542  // also add this data handle to the checker, with `false`:
543  // `tcpsChecker.addInput(datahandle, context, false);`
544  // - after all the inputs (primary & secondary) have been added to the
545  // checker, check to see if there's an issue:
546  // `tcpsChecker.checkForDifferingTCPS();`
547  //
549  {
550  public:
551  explicit DifferingTimeCodesPerSecChecker(LOP_Node *lop) : myLop(lop) {}
552  void addInput(
553  const HUSD_DataHandle &handle,
554  OP_Context &context,
555  bool onlyTimeDep = true);
556  // Returns `true` if there are differing values; `false` otherwise
557  bool checkForDifferingTCPS(bool emitWarning = true);
558 
559  private:
560  LOP_Node *myLop;
561  std::set<fpreal64> myTCPSEntries;
562  };
563 
564 private:
565  // Resolves a node path pointing to a LOP node into an HUSD_LockedStagePtr.
566  // This is used by husdLopStageResolver in HUSD_Utils.C to help the
567  // GusdStageCache convert "op:/" USD file names into a stage generated
568  // by a LOP node.
569  static HUSD_LockedStagePtr resolveStage(const UT_StringRef &path);
570 
571  // Helper function used by cookReferenceNodeWithReplacement methods.
572  OP_ERROR copyDataWithReplacement(
573  HUSD_DataHandle &data_handle,
574  const UT_StringRef &from_path_pattern,
575  const LOP_LayerReplacementInfo &replacement_info,
576  UT_StringSet &replaced_layers);
577  void setDebugDirtyRecursive(
578  void *change_data, bool top_level);
579  void resetDataHandle();
580 
581  HUSD_DataHandle myDataHandle;
582  LOP_LayerCheckpoints myCheckpoints;
583  HUSD_PathSet myLastModifiedPrims;
584  bool myLastCookActivation;
585  bool myHasActivationParameter;
586  bool myHasShotActivationParameter;
587 };
588 
589 #endif
virtual int saveCookedData(std::ostream &os, OP_Context &, int binary=0)=0
Definition: UT_Set.h:58
int myEvaluatingInputNameIndex
Definition: LOP_Node.h:520
fpreal getH() const override
Node position/scale is used by the UI.
virtual bool getUseBypassLook(const OP_EditorContext &ctx) const
fpreal getW() const override
Node position/scale is used by the UI.
UT_StringHolder myCollectionExpansionRule
Definition: LOP_Node.h:127
UT_SharedPtr< HUSD_LoadMasks > HUSD_LoadMasksPtr
UT_StringHolder myPrimPath
Definition: LOP_Node.h:95
virtual UT_AttributeEvaluator * createAttributeEvaluator(const char *name)
HUSD_MakeNewPathFunc myMakeNewPathFn
Definition: LOP_Node.h:65
void addMessage(int code, const char *msg=0)
Definition: LOP_Node.h:334
HUSD_XformStyle myValueXformStyle
Definition: LOP_Node.h:113
virtual void getAttributeEvaluatorNames(UT_StringArray &names)
#define SYS_VISIBILITY_EXPORT
HUSD_XformStyle
Definition: HUSD_Xform.h:34
#define LOP_OPTYPE_NAME
Definition: OP_Node.h:318
virtual void setFlag(char tag, int8 val)
UT_StringHolder myReplacementIdentifier
Definition: LOP_Node.h:64
UT_StringHolder myRampBasisAttrName
Definition: LOP_Node.h:98
const GLuint GLenum const void * binary
Definition: glcorearb.h:1924
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
int OP_InputIdx
Definition: OP_DataTypes.h:184
UT_StringHolder myValueType
Definition: LOP_Node.h:108
UT_ErrorSeverity
Definition: UT_Error.h:25
LOP_InputNameVariableId
Definition: LOP_Node.h:50
UT_StringHolder myCreateNewSublayerName
Definition: LOP_Node.h:70
Each instance is a tab.
Definition: PRM_Type.h:431
virtual OP_ERROR cookMe(OP_Context &context)=0
virtual void childFlagChange(OP_Node *)
UT_StringHolder myRampPosAttrName
Definition: LOP_Node.h:100
double fpreal64
Definition: SYS_Types.h:201
void opChanged(OP_EventType reason, void *data=nullptr) override
UT_StringHolder myControl
Definition: LOP_Node.h:101
virtual const char * inputLabel(OP_InputIdx idx) const
UT_StringHolder myCollectionIcon
Definition: LOP_Node.h:128
bool myCollectionUsePathExpr
Definition: LOP_Node.h:129
PRM_Type myParmType
Definition: LOP_Node.h:103
virtual bool showConvexHull() const
Definition: LOP_Node.h:301
virtual OP_Node * getCurrentNodePtr()
UT_StringMap< UT_UniquePtr< UT_AttributeEvaluator > > myEvaluators
Definition: LOP_Node.h:519
bool myCollectionAllowInstanceProxies
Definition: LOP_Node.h:130
UT_Array< LOP_AttributeParmSet > LOP_AttributeParms
Definition: LOP_Node.h:132
virtual bool getCameraInfo(const UT_StringRef &camid, const OP_Context &context, DEP_MicroNode *depnode, UT_StringHolder &foundcamid, UT_CameraParms &camparms)
SYS_VISIBILITY_EXPORT void newLopOperator(OP_OperatorTable *table)
OP_OpTypeId
Definition: OP_OpTypeId.h:18
void addWarning(int code, const char *msg=0)
Definition: LOP_Node.h:331
#define LOP_API
Definition: LOP_API.h:10
PRM_MultiType myMultiParmType
Definition: LOP_Node.h:104
GLuint const GLchar * name
Definition: glcorearb.h:786
LOP_ErrorCodes
Definition: LOP_Error.h:16
signed char int8
Definition: SYS_Types.h:35
GLushort pattern
Definition: glad.h:2583
virtual OP_DataType getCookedDataType() const =0
GLenum GLenum GLsizei void * table
Definition: glad.h:5129
virtual OP_OpTypeId getOpTypeID() const
Definition: OP_Node.h:547
UT_StringHolder myConnection
Definition: LOP_Node.h:107
GLdouble t
Definition: glad.h:2397
UT_Function< UT_StringHolder(const UT_StringRef &oldpath)> HUSD_MakeNewPathFunc
UT_StringHolder myRampCountAttrName
Definition: LOP_Node.h:97
virtual int contextOptionsStackEffect(int input) const
Definition: LOP_Node.h:303
virtual const char * getChildType() const
static const char * theChildTableName
Definition: LOP_Node.h:138
UT_StringHolder myAttrName
Definition: LOP_Node.h:96
**Note that the tasks the is the thread number *for the or if it s being executed by a non pool thread(this *can happen in cases where the whole pool is occupied and the calling *thread contributes to running the work load).**Thread pool.Have fun
virtual const char * getFileExtension(int binary) const =0
GA_API const UT_StringHolder parms
void addSystemError(const char *msg=0)
Definition: LOP_Node.h:326
Parameters for OP_Node::fillInfoTree()/OP_Node::fillInfoTreeNodeSpecific()
virtual void fillInfoTreeNodeSpecific(UT_InfoTree &tree, const OP_NodeInfoTreeParms &parms)
LOP_ActivationState
Definition: LOP_Node.h:55
UT_StringHolder myCollectionParmPrefix
Definition: LOP_Node.h:123
LOP_EditableObject
Definition: LOP_Node.h:44
fpreal64 fpreal
Definition: SYS_Types.h:278
UT_StringHolder myCollectionIncludePattern
Definition: LOP_Node.h:125
UT_SharedPtr< HUSD_LockedStage > HUSD_LockedStagePtr
Utility class for containing a color ramp.
Definition: UT_Ramp.h:96
virtual const char * getOpType() const
UT_StringHolder myApiSchema
Definition: LOP_Node.h:105
GLuint GLfloat * val
Definition: glcorearb.h:1608
UT_StringHolder myInterpolation
Definition: LOP_Node.h:102
UT_StringHolder myValueStr
Definition: LOP_Node.h:109
OP_EventType
Definition: OP_Value.h:22
OP_DataType
Definition: OP_DataTypes.h:189
virtual OP_OpTypeId getChildTypeID() const =0
int OP_OutputIdx
Definition: OP_DataTypes.h:185
virtual int getRelativeTransform(OP_Node &to, UT_Matrix4 &xform, OP_Context &context)
UT_StringHolder myXformParmPrefix
Definition: LOP_Node.h:106
virtual bool evalVariableValue(UT_String &val, int index, int thread)
virtual bool getWorldTransformFromData(const UT_StringRef &id, const OP_Context &context, bool get_inverse_xform, DEP_MicroNode *depnode, UT_DMatrix4 &xform)
void addError(int code, const char *msg=0)
Definition: LOP_Node.h:328
UT_StringHolder myCollectionName
Definition: LOP_Node.h:124
virtual bool getDebug() const
Definition: OP_Node.h:1412
virtual const char * outputLabel(OP_OutputIdx idx) const
UT_StringHolder myCollectionExcludePattern
Definition: LOP_Node.h:126
GLuint * ids
Definition: glcorearb.h:652
virtual OP_ERROR bypassMe(OP_Context &context, int &copied_input)=0
state
Definition: core.h:2289
UT_LockedRawPtr< UT_ErrorManager, OP_Lock > getLockedErrorManager()
fpreal64 myValueFloat[16]
Definition: LOP_Node.h:111
Definition: format.h:1821
virtual OP_Node * getDisplayNodePtr()
PRM_MultiType
This type enum defines the different types of multi (dynamic) parameters.
Definition: PRM_Type.h:426
virtual void clearCache()
virtual void onCreated()
Overriden in VOPs.
Definition: OP_Node.h:3190
virtual bool setDebug(bool on_off)
Definition: OP_Node.h:1366
bool lastCookActivationState() const
Definition: LOP_Node.h:317
virtual void deleteCookedData()=0