HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PI_ResourceManager.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: PI_ResourceManager.h ( Direct Manipulation Library, C++)
7  *
8  * COMMENTS:
9  * This class maintains a table of all states, handles, op-handle links,
10  * and input selectors. All state, handle, and op-handle link objects
11  * are created and deleted through a PI_ResourceManager. The active one
12  * is obtained via the global function BMgetResourceManager().
13  */
14 
15 #ifndef __PI_ResourceManager_H__
16 #define __PI_ResourceManager_H__
17 
18 #include "PI_API.h"
19 #include "PI_ResourceTemplate.h"
20 #include "PI_SettingList.h"
21 #include "PI_PythonResourceTypes.h"
22 
23 #include <OP/OP_Error.h>
24 #include <OP/OP_OperatorTable.h>
25 #include <UT/UT_Array.h>
26 #include <UT/UT_String.h>
27 #include <UT/UT_StringMap.h>
28 #include <UT/UT_SymbolTable.h>
29 #include <UT/UT_ValArray.h>
30 #include <SYS/SYS_Hash.h>
31 #include <utility>
32 
33 class CPP_Manager;
34 class PRM_Template;
35 class OP_Operator;
36 class OP_OperatorTable;
37 class OP_Node;
38 class CMD_Args;
39 class PI_OpHandleLink;
40 class pi_OpHandleBinding;
41 class pi_OpSelectorBinding;
42 
43 namespace PI_PythonState
44 {
45  class Template;
46 }
47 
48 namespace PI_PythonHandle
49 {
50  class Template;
51 }
52 
53 /// Error codes retured by PI_ResourceManager bind methods
54 /// @{
55 #define PI_BIND_OK 1
56 #define PI_NO_TEMPLATE_FOR_HANDLE -2
57 #define PI_INVALID_OP_PARM -3
58 #define PI_INVALID_PI_PARM -4
59 #define PI_BINDING_EXISTS -5
60 #define PI_INVALID_OP_FOR_PI -6
61 /// @}
62 
63 typedef void (*PI_SaveCallback)(void *data);
64 
66 {
67 public:
69 
70  // Note this is the channel name: the receiver should do a
71  // PRM_ParmList::getParmPtrFromChannel to get the parm.
72  const UT_String &getOpParm() const
73  { return myOpParm; }
74  const UT_String &getPIParm() const
75  { return myPIParm; }
76  int operator==(const PI_BindingParmInfo &i) const
77  { return (this == &i); }
78 
79 private:
80  UT_String myOpParm;
81  UT_String myPIParm;
82  friend class pi_OpHandleBinding;
83 };
84 
89 
91 {
92 public:
94 
95  const UT_String &getPIName() const
96  { return myPIName; }
97  const UT_String &getPIDescription() const
98  { return myPIDescription; }
100  { return myDefaultSettings; }
101  int getId() const
102  { return myId; }
104  { return myBindings; }
105  int operator==(const PI_BindingHandleInfo &i) const
106  { return (this == &i); }
107 
108 private:
109  UT_String myPIName;
110  UT_String myPIDescription;
111  PI_SettingList myDefaultSettings;
112  int myId;
113  PI_BindingParmArray myBindings;
114  friend class pi_OpHandleBinding;
115 };
117 
118 // See the bindSelector function for a description of all the data
119 // members of this class. They map directly to the bindSelector parameters.
121 {
122 public:
124 
125  const UT_String &getName() const
126  { return myName; }
127  const UT_String &getDescription() const
128  { return myDescription; }
129  const UT_String &getPrompt() const
130  { return myPrompt; }
131  const UT_String &getOpParm() const
132  { return myOpParm; }
133  const UT_String &getMenu() const
134  { return myMenu; }
135  const UT_String &getPrimMask() const
136  { return myPrimMask; }
137  int getOpInput() const
138  { return myOpInput; }
139  bool getOpInputReq() const
140  { return myOpInputReq; }
141  bool getAllowDrag() const
142  { return myAllowDrag; }
143  bool getAstSelAll() const
144  { return myAstSelAll; }
145  const UT_String &getExtraInfo() const
146  { return myExtraInfo; }
147  int operator==(const PI_BindingSelectorInfo &i) const
148  { return (this == &i); }
149 
150 private:
151  UT_String myName;
152  UT_String myDescription;
153  UT_String myPrompt;
154  UT_String myOpParm;
155  UT_String myMenu;
156  UT_String myPrimMask;
157  int myOpInput;
158  bool myOpInputReq;
159  bool myAllowDrag;
160  bool myAstSelAll;
161  UT_String myExtraInfo;
162  friend class pi_OpSelectorBinding;
163 };
165 
168 {
169 public:
171  ~PI_ResourceManager() override;
172 
173  // Return 1 on success and 0 if the state/handle/op-handle link
174  // is already registered.
175  virtual int registerState(PI_StateTemplate *type);
176  virtual int registerHandle(PI_HandleTemplate *type);
177  virtual int registerOpHandleLink(PI_PITemplate *type);
178  virtual int registerSelector(PI_SelectorTemplate *type);
179 
180  bool containsState(const char *name,
181  PI_ViewerType viewer_type,
182  unsigned netmask) const;
183  bool containsHandle(const char *name) const;
184  bool containsOpHandleLink(const char *name) const;
185  bool containsSelector(const char *name) const;
186 
187  // Get all the bound handles and parms for a given op type.
189  *getBindingHandles(OP_Operator *op) const;
190  // Get all the bound selectors for a given op type.
192  *getBindingSelectors(OP_Operator *op) const;
193 
194  // Return the list of states that can be used in a viewer for the
195  // specified network type.
197  &stateList(PI_ViewerType viewer_type,
198  const char *network_type) const;
200  &stateList(PI_ViewerType viewer_type,
201  PI_NetworkType net_type) const;
202  PI_StateTemplate *getStateTemplate(const char *name,
203  PI_ViewerType viewer_type,
204  const char *type) const;
205  PI_StateTemplate *getStateTemplate(OP_Operator *op,
206  PI_ViewerType viewer_type,
207  const char *type) const;
208 
209  // Viewer state handling
210  // Return the registration status of a state template.
212  getViewerStateRegisterStatus(
213  const char* state_name, PI_ViewerType viewer_type, const char* type) const;
214 
215  // Fires a register viewer state event callback
216  virtual void fireResourceEvent(
219  PI_PythonResource::EventMessage::Data const& event_data);
220 
221  // return true if the state name is valid
222  bool validStateTemplateName(const char* name) const;
223 
224  // unregister a python viewer state
225  virtual PI_PythonResource::Status unregisterViewerState(const char* name);
226 
227  // return true if a viewer state is registered
228  virtual bool isRegisteredViewerState(const char* name) const;
229 
230  // return a viewer state given a name
231  virtual PI_PythonState::Template const * viewerStateTemplate(const char * state_name) const;
232  virtual PI_PythonState::Template * viewerStateTemplate(const char * state_name) ;
233 
234  // Viewer Handles
235  virtual PI_PythonResource::Status unregisterViewerHandle(const char* name);
236  virtual bool isRegisteredViewerHandle(const char* name) const;
237 
238  virtual PI_PythonHandle::Template const*
239  viewerHandleTemplate(const char* handle_name) const;
240 
241  // Returns the registered viewer handle types (PI template name)
242  virtual UT_StringArray const & getViewerHandleTypeNames() const;
243 
244  // These are functions which are called from commands that allow
245  // for dynamic binding of handles to parameters
246  int unbind(OP_Operator *op, const char *pidescription,
247  const UT_String &opparm);
248  int bind(OP_Operator *op, const char *piname,
249  const char *pidescription,
250  const UT_String &opparm,
251  const UT_String &piparm,
252  const char *default_settings);
253  // this API is typically used for handle late-binding e.g. python states
254  // would provide functions for binding handle parms
255  int bind(OP_Operator *op, const char *piname,
256  const char *pidescription,
257  const char *default_settings);
258  int bindScriptOp(OP_Operator *op, const char *piname,
259  const char *pidescription,
260  const UT_String &opparm,
261  const UT_String &piparm,
262  const char *default_settings);
263 
264  // Used for binding node operators to registered viewer states (i..e. python states)
265  // returns true if the operation succeeded
266  virtual bool bindOperatorToViewerState(const char* state_name, OP_Operator* op);
267 
268  // Returns true if a state is expected to exist for an operator of a given
269  // network type. By design, management operators are not expected to operate
270  // outside their own network, this function will return false in this case.
271  //
272  // op_name: operator name
273  // op_type: operator type e.g. DOP
274  bool operatorStateMandatory(const char* op_name, const char* op_type) const;
275 
276  /// Unbind the given selector from an operator. Uses the short description
277  /// when bound using bindSelector()
278  int unbindSelector(OP_Operator *op,
279  const char *seldescription);
280 
281  /// Dynamic binding of a selector to an operator
282  ///
283  /// @param op Operator type that we want to bind a selector to
284  /// @param sname Selector type
285  /// @param seldescription Short description that identifies this selector
286  /// in the context of a one operator (used to
287  /// unbind the selector).
288  /// @param prompt Text in the status area when the selector is
289  /// active.
290  /// @param opparm Operator parameter where the selection string
291  /// is put.
292  /// @param opinput Wire input index where the op owning the
293  /// selected geometry is attached to our op.
294  /// @param opinputreq Is an input is required?
295  /// @param primmask Mask of which primitive types can be in the
296  /// selection. This uses the *_FILEID enum in
297  /// GEO_PrimTypeCompat.h. A regular
298  /// GEO_PrimTypeCompat mask can be used if you
299  /// first convert it using
300  /// GEO_PrimTypeCompat::convertToFileFromMask()
301  /// @param allowdrag Determines if click-and-drag operations are
302  /// allowed.
303  /// @param menu Operator menu parameter where we choose the
304  /// selection type.
305  /// @param astselall If an asterisk is required in the selection
306  /// string to indicate selecting all the input.
307  /// Otherwise we assume an empty string indicates
308  /// that the whole geometry is selected.
309  /// @param extrainfo String that is passed to the selector,
310  /// particular selectors may need specific
311  /// parameters that can be passed through this
312  /// mechanism.
313  /// @param fromScriptOp Used by our dialog script parser to avoid
314  /// infinite recursion. Setting this flag decreases
315  /// the error checking we do.
316  ///
317  /// @return PI_BIND_OK upon success, else see of one of the other potential
318  /// error codes at the top of PI_ResourceManager.h
319  int bindSelector(OP_Operator *op, const char *sname,
320  const char *seldescription,
321  const char *prompt, const char *opparm,
322  int opinput, int opinputreq,
323  const char *primmask, int allowdrag,
324  const char *menu, int astselall,
325  const char *extrainfo, bool fromScriptOp);
326 
327  //Helper functions for the above
328  PRM_Template *getTemplateAndVecId(const UT_String &,
329  OP_Operator *,
330  int &) const;
331 
332  // This is for converting old style "t 2" into new style "tz". It
333  // only works if the operator has the template already, else it
334  // assumes channel name == parmname. Thus, it won't work on
335  // multiparms that only exist with OP_Node, not OP_Operator.
336  void getChannelNameFromParmAndVec(UT_String &chan,
337  OP_Operator *op, const char *parmname,
338  int vecidx);
339 
340  int checkForPIName( const char *pi_name,
341  const char *pi_parm ) const;
342 
343  OP_Operator *findOperator(PI_NetworkType net_type,
344  const char *op_name,
345  bool display_warning = true) const;
346  OP_Operator *findOperator(const char *opbindname,
347  UT_String *optype = 0) const;
348 
349  virtual void findVolatileKeys(const char *volatile_hotkey_name,
350  UT_Array<int> &volatile_keys,
351  UT_Array<int> &keys_modifiers)
352  const;
353  virtual void updateViewports(int id, const char *opname,
354  bool open_only = false) const;
355 
356  //These methods are used in PI_ResourceManagerCommand.C.
357  const PI_OpHandleLinkMap &getOpHandleLinks() const { return myOpHandleLinks; }
358  PI_PITemplate *getOpHandleLinkTemplate(const char *pi_name) const;
359  const PI_SelectorTemplateMap &getSelectors() const { return mySelectors; }
360  PI_SelectorTemplate *getSelectorTemplate(const char *selector_name) const;
361 
362  // Returns a list of all builtin op handles
363  const UT_StringArray &getBuiltinOpHandleNames();
364 
365  // The following method is used by builddialogs
366  const PI_HandleTemplateMap &getHandles() const { return myHandles; }
367 
368  // Tell us if the pi with the given name is an invisible PI by nature.
369  // Optionally return the type of the pi in isfloat (int or float assumed)
370  bool isPIEthereal(const char *piname,
371  bool *isfloat = 0) const;
372 
373  // Because the order of callbacks for OP_UpdateTableSink is
374  // undefined, some callbacks rely on the resource manager's table of states
375  // to be accurate. Since the resource manager's callback can happen
376  // after the other callbacks, they can call these methods to ensure the
377  // resource manager's table is accurate.
378  void ensureStatesExistForAllOperators(const char *net_type_name);
379  virtual void ensureStatesExistForAllOperators(PI_NetworkType net_type);
380 
381  // Map a viewer type token to a PI_ViewerType, or vice-versa.
382  static bool getViewerType(const char *viewer_type_token,
383  PI_ViewerType &type);
384  static void getViewerTypeToken(PI_ViewerType type,
385  UT_String &viewer_type_token);
386 
387  // Map the network name returned by OP_Node::getOpType() to a
388  // PI_NetworkType, or vice-versa.
389  static bool getNetworkType(const char *network_type_name,
390  PI_NetworkType &type);
391  static const UT_StringHolder &getNetworkTypeName(PI_NetworkType type);
392  static OP_OperatorTable *getOpTableFromOperator(const OP_Operator *op);
393 
394  // Choose the first network type from a mask that contains multiple ones.
395  static PI_NetworkType getFirstNetworkType(unsigned int network_mask);
396 
397  static PRM_Template *findParmTemplate(OP_Operator &op,
398  const char *op_Parm_name,
399  int vec_idx, int *parm_idx);
400 
401  // Write out our bindings information to a file.
402  int writeBindingsFile(const char *fname) const;
403 
404  // Load/save/remove the settings for a particular PI and a node that's
405  // linked to it.
406  void loadPISettingsFromTables(PI_OpHandleLink &pi,
407  bool okay_to_use_last_settings) const;
408  void savePISettingsToTables(PI_OpHandleLink &pi);
409  virtual void removePISettingsFromTables(OP_Operator &op_type);
410  void removePISettingsFromTables(const PI_OpHandleLink &pi);
411 
412  // Record settings for a particular PI. This method should only be
413  // called by the omparm command.
414  void recordPISettings(const char *pi_description,
415  const char *pi_type,
416  const OP_Node &op_node,
417  const char *settings);
418 
419  // Objects may add callbacks that are called just before the resource
420  // manager saves its data to the hip file. These callbacks update
421  // the resource manager to make sure the data it saves is current.
422  void addSaveCallback(PI_SaveCallback callback, void *data);
423  void removeSaveCallback(PI_SaveCallback callback,
424  void *data);
425 
426  void registerOpHandleBindings();
427  virtual void removeAllBindings(OP_Operator *op);
428 
429  // Returns the name of the state being created
430  char const* stateToCreate() const;
431 
432  // Set by BM_PythonSupport to give access to the python support
433  // object while the python resource instance is being created.
434  void setPythonResourceSupport(void* res_support);
435  void* getPythonResourceSupport();
436 
437 protected:
438  static void startParmsCache();
439  static void stopParmsCache();
440  static void getParmsCache(UT_ValArray<OP_Node *> *&ops,
441  UT_ValArray<PRM_Parm *> *&parms,
442  UT_IntArray *&vec_indices);
443  static void getParmsCacheBehaviour( bool &set_keys,
444  bool &do_scope,
445  bool &append_scope );
446 
447  // Save the name of the state being created.
448  void saveStateToCreate(char const* state);
449 public:
450  static int cacheParms();
451  static void appendToParmsCache(OP_Node *op, PRM_Parm *parm,
452  int vi);
453  static void setParmsCacheBehaviour( bool set_keys, bool do_scope,
454  bool append_scope );
455 
457  { return theHideLockedHandleParts; }
458  static void setHideLockedHandleParts( bool hide )
459  { theHideLockedHandleParts = hide; }
460  static bool getScopeChannelsOnKey()
461  { return theScopeChannelsOnKey; }
462  static void setScopeChannelsOnKey( bool scope )
463  { theScopeChannelsOnKey = scope; }
464  static bool getAddScopedChannels()
465  { return theAddScopedChannels; }
466  static void setAddScopedChannels( bool add )
467  { theAddScopedChannels = add; }
469  { return theOpenChannelEditorOnScope; }
470  static void setOpenChannelEditorOnScope( bool do_open )
471  { theOpenChannelEditorOnScope = do_open; }
472  static void getChannelScopeCommandPrefix( UT_String &str );
473 
474 
475 protected:
476  // Classes:
477 
479  {
480  public:
481  PI_OpPIKey(const char *pi_name_in_setting_table, const char *pi_type,
482  int op_id) :
483  myPINameInSettingTable(pi_name_in_setting_table),
484  myPIType(pi_type),
485  myOpId(op_id) {}
486 
487  bool operator==(const PI_OpPIKey &o) const
488  {
489  // myPIType is not used.
490  return myPINameInSettingTable == o.myPINameInSettingTable &&
491  myOpId == o.myOpId;
492  }
493 
495  {
496  // myPIType is not used.
497  SYS_HashType hash = myPINameInSettingTable.hash();
498  SYShashCombine(hash, myOpId);
499  return hash;
500  }
501 
502  UT_StringHolder piNameInSettingTable() const { return myPINameInSettingTable; }
503  UT_StringHolder piType() const { return myPIType; }
504  int opId() const { return myOpId; }
505 
506  struct Hasher
507  {
508  size_t operator()(const PI_OpPIKey &pk) const { return size_t(pk.hash()); }
509  };
510 
511  private:
512  UT_StringHolder myPINameInSettingTable;
513  UT_StringHolder myPIType;
514  int myOpId;
515  };
516 
518  {
521  };
522 
523  // Methods:
524 
525  void installCommands();
526  void registerOpHandleLinks();
527  void registerCopHandleLinks();
528  void registerOpHandleConstructors();
529  void registerSelectors();
530  void registerSelectorConstructors();
531 
532  // Functions used by registerOpHandleLinks for loading the OPbindings file.
533  bool isValidPiParmName( const UT_String &pi_name,
534  const UT_String &pi_parm);
535  void loadHandle(CPP_Manager &cppman, OP_Operator *op,
536  pi_OpHandleBinding *binding);
537  void loadSelector(CPP_Manager &cppman,
538  const UT_String &selname,
539  const UT_String &seldescription,
540  pi_OpSelectorBinding *binding);
541  void loadOperator(CPP_Manager &cppman,
542  const UT_String &oppath);
543  void loadOperator(CPP_Manager &cppman,
544  const UT_String &optype,
545  OP_Operator *op,
546  pi_OpHandleBinding *hbinding,
547  pi_OpSelectorBinding *sbinding);
548 
549  virtual void addAutomaticStates(PI_NetworkType net_type);
550  void tableUpdated(OP_OperatorTable *table) override;
551  void tableDeleted(OP_OperatorTable *table) override;
552  void templatesUpdated(OP_Operator *op) override;
553  void operatorDeleted(OP_Operator *op) override;
554  void ensureTableInterestExists(PI_NetworkType net_type,
556 
557  PI_HandleTemplate *getHandleTemplate(const char *handle_name) const;
558 
559  // Save all the PI settings to a stream.
560  static OP_ERROR savePIResourceManagerCallback(std::ostream &os,
561  void *data);
562  OP_ERROR saveSettings(std::ostream &os) const;
563 
564  // We need the non-const version of getDefaultPISettings() because we
565  // might need to sort the default settings.
566  const PI_SettingList *getDefaultPISettings(OP_Operator &op_type,
567  const char *type_name,
568  const char *description) const;
569  PI_SettingList *getDefaultPISettings(OP_Operator &op_type,
570  const char *type_name,
571  const char *description);
572 
573  // This method is implemented by the leaf class (i.e. MT_ResourceManager)
574  // and is used for updating the PI Settings (i.e. handle settings)
575  // loaded from the PI setting tables (loadPISettingsFromTables).
576  // MT_ResourceManager uses the latest PI settings registered by a
577  // python state to update the loaded settings.
578 
579  // pi_settings: The PI settings to update. The implementation should
580  // update it directly and return the same pointer.
581  // op: The owner operator.
582  // pi_type: The PI type name.
583  // pi_name: The PI description name.
584  virtual PI_SettingList const * onUpdatePISettings( PI_SettingList const& pi_settings,
585  OP_Operator & op,
586  char const* pi_type,
587  char const* pi_name) const;
588 
589  // Data:
590  using PI_SaveCallbackInfo = std::pair<PI_SaveCallback, void *>;
597 
600 
603 
607 
609  void* myCurrentPythonSupport = nullptr;
610 
611  static bool ourSetKeyOnParms;
612  static bool ourScopeParmChannels;
613  static bool ourAppendToScope;
614  static int ourCacheParms;
618 
621  static bool theAddScopedChannels;
623 };
624 
626 PI_API extern void PIcreateResourceManager(bool verbose=true);
627 PI_API extern bool PIresourceManagerExists();
628 
629 #endif
int operator==(const PI_BindingSelectorInfo &i) const
int operator==(const PI_BindingHandleInfo &i) const
const UT_String & getPrompt() const
UT_StringHolder piNameInSettingTable() const
Unsorted map container.
Definition: UT_Map.h:83
const PI_OpHandleLinkMap & getOpHandleLinks() const
UT_Array< PI_SaveCallbackInfo > mySaveCallbacks
PI_HandleTemplateMap myHandles
static bool theOpenChannelEditorOnScope
void
Definition: png.h:1083
const PI_SelectorTemplateMap & getSelectors() const
static UT_ValArray< OP_Node * > ourParmNodes
UT_StringArray myBuiltinOpHandleNames
UT_SymbolMap< pi_OpHandleBinding * > myOpHandleBindings
PI_API void PIcreateResourceManager(bool verbose=true)
static void setScopeChannelsOnKey(bool scope)
PI_OpHandleLinkMap myOpHandleLinks
PI_NetworkType
static bool getAddScopedChannels()
PI_ViewerType
PI_OpPIKey(const char *pi_name_in_setting_table, const char *pi_type, int op_id)
std::size_t SYS_HashType
Define the type for hash values.
Definition: SYS_Hash.h:19
UT_ErrorSeverity
Definition: UT_Error.h:25
const PI_SettingList & getDefaultSettings() const
#define PI_API
Definition: PI_API.h:10
GLuint const GLchar * name
Definition: glcorearb.h:785
static void setOpenChannelEditorOnScope(bool do_open)
PI_API bool PIresourceManagerExists()
UT_StringHolder piType() const
void(* PI_SaveCallback)(void *data)
PI_SelectorTemplateMap mySelectors
const UT_String & getPIDescription() const
static bool theHideLockedHandleParts
bool operator==(const PI_OpPIKey &o) const
static bool theScopeChannelsOnKey
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
UT_SymbolMap< PI_NetworkType > myNetworkTypeTable
static UT_IntArray ourParmVecIndices
static bool ourScopeParmChannels
const UT_String & getOpParm() const
size_t operator()(const PI_OpPIKey &pk) const
static bool getHideLockedHandleParts()
const UT_String & getPrimMask() const
std::pair< PI_SaveCallback, void * > PI_SaveCallbackInfo
static bool getOpenChannelEditorOnScope()
static void setAddScopedChannels(bool add)
const UT_String & getExtraInfo() const
static bool getScopeChannelsOnKey()
PI_API PI_ResourceManager * PIgetResourceManager()
GLboolean * data
Definition: glcorearb.h:130
static void setHideLockedHandleParts(bool hide)
static bool theAddScopedChannels
const UT_String & getPIName() const
const PI_HandleTemplateMap & getHandles() const
const PI_BindingParmArray & getBindings() const
const UT_String & getMenu() const
static bool ourSetKeyOnParms
UT_StringHolder myStateBeingCreated
UT_Map< PI_OpPIKey, OpPISettingInfo, PI_OpPIKey::Hasher > myPISettingsForOps
const UT_String & getDescription() const
constexpr T pi()
Pi constant taken from Boost to match old behaviour.
Definition: Math.h:118
UT_SymbolMap< pi_OpSelectorBinding * > myOpSelectorBindings
static UT_ValArray< PRM_Parm * > ourParms
ImageBuf OIIO_API add(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
int operator==(const PI_BindingParmInfo &i) const
static bool ourAppendToScope
const UT_String & getName() const
UT_StringMap< PI_SettingList * > myLastPISettings
GLenum GLsizei GLenum GLenum const void * table
Definition: glew.h:4970
const UT_String & getPIParm() const
const UT_String & getOpParm() const