HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OP_Utils.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: OP Library (C++)
7  *
8  * COMMENTS: Some utility functions for operators.
9  *
10  */
11 
12 #ifndef __OP_Utils_h__
13 #define __OP_Utils_h__
14 
15 #include "OP_API.h"
16 #include "OP_Node.h"
17 #include <UT/UT_Matrix2.h>
18 #include <UT/UT_Matrix3.h>
19 #include <UT/UT_Matrix4.h>
20 #include <UT/UT_Ramp.h>
21 #include <UT/UT_Vector2.h>
22 #include <UT/UT_Vector3.h>
23 #include <UT/UT_Vector4.h>
24 #include <UT/UT_WeakPtr.h>
25 
26 class OP_NetworkBoxItem;
27 class PY_Result;
28 class UT_BitArray;
29 class UT_WorkBuffer;
30 class UT_StringArray;
31 
33  const UT_StringArray &badrefs);
35  bool checktoplevelnode,
36  UT_WorkBuffer &err);
38  bool checktoplevelnode,
39  UT_WorkBuffer &err);
40 
41 /// Looks for any nodes inside the specified operator that are defined by
42 /// VOP Networks outside the provided node. REtrns true if no such nodes
43 /// are found. Otherwise it puts an error message in the err buffer and
44 /// returns false.
46  UT_WorkBuffer &err);
48  UT_String &vopnetmask);
49 /// Adds a new vopnet mask string to the list of known vopnet context types.
50 /// This list is used to generate a VopNet Mask value when creating an HDA
51 /// from an existing subnet VOP.
53 
54 /// @{ Functions for testing whether a node parameter is used as a shader
55 /// parameter, when the node represents a shader. Some node parameters may
56 /// belong to only certain contexts (eg, surface shader), while other ones
57 /// may be just true spare parameters that are not shader parameters at all.
59 OP_API bool OPisStandInShaderParm(const PRM_Template &parm);
61  const char *context_name);
62 OP_API bool OPisLegacyShaderParm(const PRM_Template &parm, OP_Node *owner);
63 OP_API bool OPhasShaderContextTag(const PRM_Template *list,
64  int start = 0, int end = -1);
65 /// @}
66 
67 OP_API OP_Node *OPfindOpInput(OP_Node *op, const char *find_op_type,
68  bool include_me = true);
69 OP_API OP_Node *OPfindOpInput(OP_Node *op, const char **find_op_types,
70  bool include_me = true);
71 
72 /// Returns coordinates specifying the smallest possible bounding box
73 /// around the items in 'items'. Takes each item's height and width into
74 /// consideration.
76  const OP_NetworkBoxItemList &items);
77 
78 /// Looks for any VOP Networks inside the specified node which define operator
79 /// types that are instantiated outside the node. If it returns false, the
80 /// badvopnets array will be filled with the VOP Networks that are used
81 /// outside the root node.
83  OP_NodeList *badvopnets);
84 
85 /// Creates a sticky note about the lack of vops inside synced HDAs, since the
86 /// children have been removed because the subnet is using cached code.
88 
89 /// Given a set of unique nodes, compute a topological ordering using only the
90 /// connectivity amongst the given nodes. If the roots are not known, then it
91 /// will be internally computed using OPmarkNodeRoots(only_picked=false).
92 /// Otherwise, the nodes will only be sorted by traversing from the given root
93 /// nodes.
96  const OP_NodeList &nodes,
97  const UT_BitArray *roots = nullptr);
98 
99 /// Given a set of nodes return a bit array indicating the nodes which are
100 /// roots WITHIN THE SET. If assume_picked is true, then it's assumed that the
101 /// node is in the set if and only if it's in the set.
103  UT_BitArray &roots,
104  const OP_NodeList &nodes,
105  bool assume_picked);
106 
107 namespace OP_Utils
108 {
109  // Boiler plate to load individual types from op.
110  static inline void evalOpParm(
111  int64 &v, const OP_Node *node, const char *parmname, fpreal time,
112  DEP_MicroNode *depnode)
113  { v = node->evalInt(parmname, 0, time);
114  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
115  }
116  static inline void evalOpParm(
117  bool &v, const OP_Node *node, const char *parmname, fpreal time,
118  DEP_MicroNode *depnode)
119  { v = node->evalInt(parmname, 0, time);
120  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
121  }
122  static inline void evalOpParm(
123  fpreal64 &v, const OP_Node *node, const char *parmname, fpreal time,
124  DEP_MicroNode *depnode)
125  { v = node->evalFloat(parmname, 0, time);
126  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
127  }
128  static inline void evalOpParm(
129  UT_Vector2D &v, const OP_Node *node, const char *parmname, fpreal time,
130  DEP_MicroNode *depnode)
131  { v.x() = node->evalFloat(parmname, 0, time);
132  v.y() = node->evalFloat(parmname, 1, time);
133  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
134  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
135  }
136  static inline void evalOpParm(
137  UT_Vector3D &v, const OP_Node *node, const char *parmname, fpreal time,
138  DEP_MicroNode *depnode)
139  { v.x() = node->evalFloat(parmname, 0, time);
140  v.y() = node->evalFloat(parmname, 1, time);
141  v.z() = node->evalFloat(parmname, 2, time);
142  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
143  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
144  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(2));
145  }
146  static inline void evalOpParm(
147  UT_Vector4D &v, const OP_Node *node, const char *parmname, fpreal time,
148  DEP_MicroNode *depnode)
149  { v.x() = node->evalFloat(parmname, 0, time);
150  v.y() = node->evalFloat(parmname, 1, time);
151  v.z() = node->evalFloat(parmname, 2, time);
152  v.w() = node->evalFloat(parmname, 3, time);
153  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
154  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
155  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(2));
156  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(3));
157  }
158 
159  static inline void evalOpParm(
160  UT_Matrix2D &v, const OP_Node *node, const char *parmname, fpreal time,
161  DEP_MicroNode *depnode)
162  { for (int r = 0; r < 2; r++)
163  {
164  for (int c = 0; c < 2; c++)
165  {
166  v(r, c) = node->evalFloat(parmname, r * 2 + c, time);
167  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(r * 2 + c));
168  }
169  }
170  }
171  static inline void evalOpParm(
172  UT_Matrix3D &v, const OP_Node *node, const char *parmname, fpreal time,
173  DEP_MicroNode *depnode)
174  { for (int r = 0; r < 3; r++)
175  {
176  for (int c = 0; c < 3; c++)
177  {
178  v(r, c) = node->evalFloat(parmname, r * 3 + c, time);
179  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(r * 3 + c));
180  }
181  }
182  }
183  static inline void evalOpParm(
184  UT_Matrix4D &v, const OP_Node *node, const char *parmname, fpreal time,
185  DEP_MicroNode *depnode)
186  { for (int r = 0; r < 4; r++)
187  {
188  for (int c = 0; c < 4; c++)
189  {
190  v(r, c) = node->evalFloat(parmname, r * 4 + c, time);
191  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(r * 4 + c));
192  }
193  }
194  }
195 
196  static void inline evalOpParm(
197  UT_Vector2I &v, const OP_Node *node, const char *parmname, fpreal time,
198  DEP_MicroNode *depnode)
199  { v.x() = node->evalInt(parmname, 0, time);
200  v.y() = node->evalInt(parmname, 1, time);
201  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
202  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
203  }
204  static void inline evalOpParm(
205  UT_Vector3I &v, const OP_Node *node, const char *parmname, fpreal time,
206  DEP_MicroNode *depnode)
207  { v.x() = node->evalInt(parmname, 0, time);
208  v.y() = node->evalInt(parmname, 1, time);
209  v.z() = node->evalInt(parmname, 2, time);
210  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
211  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
212  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(2));
213  }
214  static void inline evalOpParm(
215  UT_Vector4I &v, const OP_Node *node, const char *parmname, fpreal time,
216  DEP_MicroNode *depnode)
217  { v.x() = node->evalInt(parmname, 0, time);
218  v.y() = node->evalInt(parmname, 1, time);
219  v.z() = node->evalInt(parmname, 2, time);
220  v.w() = node->evalInt(parmname, 3, time);
221  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
222  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(1));
223  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(2));
224  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(3));
225  }
226  static void inline evalOpParm(
227  UT_StringHolder &v, const OP_Node *node, const char *parmname, fpreal time,
228  DEP_MicroNode *depnode)
229  { UT_String result; node->evalString(result, parmname, 0, time); v.adoptFromString(result);
230  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
231  }
232  static void inline evalOpParmRaw(
233  UT_StringHolder &v, const OP_Node *node, const char *parmname, fpreal time,
234  DEP_MicroNode *depnode)
235  { UT_String result; node->evalStringRaw(result, parmname, 0, time); v.adoptFromString(result);
236  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
237  }
238  static void inline evalOpParm(
239  UT_SharedPtr<UT_Ramp> &v, const OP_Node *node, const char *parmname, fpreal time,
240  DEP_MicroNode *depnode)
241  {
242  v.reset(new UT_Ramp());
243 
244  if (node->hasParm(parmname))
245  node->updateRampFromMultiParm(time, node->getParm(parmname), *v, 0, depnode);
246  }
247  static void inline evalOpParm(
248  PRM_DataItemHandle &v, const OP_Node *node, const char *parmname, fpreal time,
249  DEP_MicroNode *depnode)
250  {
251  v = node->evalData(parmname, 0, time);
252  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParm(parmname).microNode(0));
253  }
254 
255 
256  static void inline evalOpParmInst(
257  int64 &v, const OP_Node *node, const char *parmname,
258  int *inst, fpreal time,
259  DEP_MicroNode *depnode)
260  {
261  v = node->evalIntInst(parmname, inst, 0, time);
262  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
263  }
264  static void inline evalOpParmInst(
265  bool &v, const OP_Node *node, const char *parmname,
266  int *inst, fpreal time,
267  DEP_MicroNode *depnode)
268  {
269  v = node->evalIntInst(parmname, inst, 0, time);
270  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
271  }
272  static void inline evalOpParmInst(
273  fpreal64 &v, const OP_Node *node, const char *parmname,
274  int *inst, fpreal time,
275  DEP_MicroNode *depnode)
276  {
277  v = node->evalFloatInst(parmname, inst, 0, time);
278  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
279  }
280  static void inline evalOpParmInst(
281  UT_Vector2D &v, const OP_Node *node, const char *parmname,
282  int *inst, fpreal time,
283  DEP_MicroNode *depnode)
284  {
285  v.x() = node->evalFloatInst(parmname, inst, 0, time);
286  v.y() = node->evalFloatInst(parmname, inst, 1, time);
287  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
288  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
289  }
290  static void inline evalOpParmInst(
291  UT_Vector3D &v, const OP_Node *node, const char *parmname,
292  int *inst, fpreal time,
293  DEP_MicroNode *depnode)
294  {
295  v.x() = node->evalFloatInst(parmname, inst, 0, time);
296  v.y() = node->evalFloatInst(parmname, inst, 1, time);
297  v.z() = node->evalFloatInst(parmname, inst, 2, time);
298  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
299  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
300  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(2));
301  }
302  static void inline evalOpParmInst(
303  UT_Vector4D &v, const OP_Node *node, const char *parmname,
304  int *inst, fpreal time,
305  DEP_MicroNode *depnode)
306  {
307  v.x() = node->evalFloatInst(parmname, inst, 0, time);
308  v.y() = node->evalFloatInst(parmname, inst, 1, time);
309  v.z() = node->evalFloatInst(parmname, inst, 2, time);
310  v.w() = node->evalFloatInst(parmname, inst, 3, time);
311  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
312  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
313  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(2));
314  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(3));
315  }
316 
317  static void inline evalOpParmInst(
318  UT_Matrix2D &v, const OP_Node *node, const char *parmname,
319  int *inst, fpreal time,
320  DEP_MicroNode *depnode)
321  { for (int r = 0; r < 2; r++)
322  {
323  for (int c = 0; c < 2; c++)
324  {
325  v(r, c) = node->evalFloatInst(parmname, inst, r * 2 + c, time);
326  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(r * 2 + c));
327  }
328  }
329  }
330  static void inline evalOpParmInst(
331  UT_Matrix3D &v, const OP_Node *node, const char *parmname,
332  int *inst, fpreal time,
333  DEP_MicroNode *depnode)
334  { for (int r = 0; r < 3; r++)
335  {
336  for (int c = 0; c < 3; c++)
337  {
338  v(r, c) = node->evalFloatInst(parmname, inst, r * 3 + c, time);
339  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(r * 3 + c));
340  }
341  }
342  }
343  static void inline evalOpParmInst(
344  UT_Matrix4D &v, const OP_Node *node, const char *parmname,
345  int *inst, fpreal time,
346  DEP_MicroNode *depnode)
347  { for (int r = 0; r < 4; r++)
348  {
349  for (int c = 0; c < 4; c++)
350  {
351  v(r, c) = node->evalFloatInst(parmname, inst, r * 4 + c, time);
352  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(r * 4 + c));
353  }
354  }
355  }
356 
357  static void inline evalOpParmInst(
358  UT_Vector2I &v, const OP_Node *node, const char *parmname,
359  int *inst, fpreal time,
360  DEP_MicroNode *depnode)
361  {
362  v.x() = node->evalIntInst(parmname, inst, 0, time);
363  v.y() = node->evalIntInst(parmname, inst, 1, time);
364  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
365  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
366  }
367  static void inline evalOpParmInst(
368  UT_Vector3I &v, const OP_Node *node, const char *parmname,
369  int *inst, fpreal time,
370  DEP_MicroNode *depnode)
371  {
372  v.x() = node->evalIntInst(parmname, inst, 0, time);
373  v.y() = node->evalIntInst(parmname, inst, 1, time);
374  v.z() = node->evalIntInst(parmname, inst, 2, time);
375  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
376  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
377  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(2));
378  }
379  static void inline evalOpParmInst(
380  UT_Vector4I &v, const OP_Node *node, const char *parmname,
381  int *inst, fpreal time,
382  DEP_MicroNode *depnode)
383  {
384  v.x() = node->evalIntInst(parmname, inst, 0, time);
385  v.y() = node->evalIntInst(parmname, inst, 1, time);
386  v.z() = node->evalIntInst(parmname, inst, 2, time);
387  v.w() = node->evalIntInst(parmname, inst, 3, time);
388  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
389  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(1));
390  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(2));
391  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(3));
392  }
393 
394  static void inline evalOpParmInst(
395  UT_StringHolder &v, const OP_Node *node, const char *parmname,
396  int *inst, fpreal time,
397  DEP_MicroNode *depnode)
398  {
399  UT_String result; node->evalStringInst(parmname, inst, result, 0, time); v.adoptFromString(result);
400  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
401  }
402  static void inline evalOpParmInst(
403  UT_SharedPtr<UT_Ramp> &v, const OP_Node *node, const char *parmname,
404  int *inst, fpreal time,
405  DEP_MicroNode *depnode)
406  {
407  v.reset(new UT_Ramp());
408 
409  const PRM_Parm *rampparm = node->getParmList()->getParmPtrInst(parmname, inst, /*nestlevel=*/1);
410  if (rampparm)
411  node->updateRampFromMultiParm(time, *rampparm, *v, 0, depnode);
412  }
413  static void inline evalOpParmInst(
414  PRM_DataItemHandle &v, const OP_Node *node, const char *parmname,
415  int *inst, fpreal time,
416  DEP_MicroNode *depnode)
417  {
418  v = node->evalDataInst(parmname, inst, 0, time);
419  if (depnode) depnode->addExplicitInput(SYSconst_cast(node)->getParmPtrInst(parmname, inst)->microNode(0));
420  }
421 
422  // Callback class to receive the results of an OP python callback
423  // or script evaluation. Clients must implement this interface and
424  // register with registerPythonResultClient to be notified.
425  // See registerPythonResultClient, notifyPythonResultClients
427  {
428  public:
430 
431  PythonResultClient() = default;
432  virtual ~PythonResultClient() = default;
433 
434  // results: Python result structure.
435  // script_source: The script source e.g. OpInstall
436  // script_path: The script file path or a reference to the
437  // embedded node e.g. opdef:/Object/mynode?OnInstall
438  virtual void onNotifyOPPythonResult(PY_Result const & result, char const * script_source, char const * script_path) = 0;
439  };
440 
441  // Registers a client interested in the OP python script evaluation results.
443 
444  // Notifies registered PythonResultClient objects about the result of a
445  // OP python script evaluation.
446  OP_API void notifyPythonResultClients(PY_Result const & result, char const * script_source, char const * script_path);
447 }
448 
449 #endif
void adoptFromString(UT_String &str)
OP_API void OPmarkRootNodes(UT_BitArray &roots, const OP_NodeList &nodes, bool assume_picked)
GLuint const GLchar * name
Definition: glew.h:1814
OP_API bool OPconvertOrWarnExternalReferences(OP_Node *node, bool checktoplevelnode, UT_WorkBuffer &err)
OP_API OP_Node * OPfindOpInput(OP_Node *op, const char *find_op_type, bool include_me=true)
OP_API void OPaddVopSubnetMask(const UT_StringRef &name)
GT_API const UT_StringHolder time
void addExplicitInput(DEP_MicroNode &inp, bool check_dup)
Methods for manipulating explicit edges.
SYS_FORCE_INLINE T * SYSconst_cast(const T *foo)
Definition: SYS_Types.h:136
GLuint GLfloat GLfloat GLfloat x1
Definition: glew.h:12681
fpreal evalFloat(int pi, int vi, fpreal t) const
const GLdouble * v
Definition: glew.h:1391
OP_API bool OPconvertOrWarnExternalOverrides(OP_Node *node, bool checktoplevelnode, UT_WorkBuffer &err)
GLuint GLdouble GLdouble GLint GLint order
Definition: glew.h:3446
OP_API bool OPisStandInShaderParm(const PRM_Template &parm)
double fpreal64
Definition: SYS_Types.h:201
PRM_Parm & getParm(int i)
SYS_FORCE_INLINE T & y()
Definition: UT_Vector3.h:513
OP_API bool OPmatchesShaderContextTag(const PRM_Template &parm, const char *context_name)
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
void evalString(UT_String &val, int pi, int vi, fpreal t) const
OP_API void OPgetVopSubnetMask(OP_Node *node, UT_String &vopnetmask)
PRM_DataItemHandle evalDataInst(const UT_StringRef &name, const int *inst, int vi, fpreal t, int nestlevel=1) const
OP_API void OPtopologicalSort(UT_IntArray &order, const OP_NodeList &nodes, const UT_BitArray *roots=nullptr)
SYS_FORCE_INLINE T & z()
Definition: UT_Vector3.h:515
GLuint GLuint end
Definition: glew.h:1253
bool hasParm(const char *name) const
const GLfloat * c
Definition: glew.h:16296
long long int64
Definition: SYS_Types.h:116
OP_API bool OPhasShaderContextTag(const PRM_Template *list, int start=0, int end=-1)
OP_API bool OPisPotentialShaderParm(const PRM_Template &parm)
OP_API void notifyPythonResultClients(PY_Result const &result, char const *script_source, char const *script_path)
fpreal evalFloatInst(const UT_StringRef &name, const int *inst, int vi, fpreal t, int nestlevel=1) const
PRM_DataItemHandle evalData(int pi, int vi, fpreal t) const
OP_API bool OPcheckForVopnetDefinedNodes(OP_Node *node, UT_WorkBuffer &err)
GLuint start
Definition: glew.h:1253
void evalStringRaw(UT_String &val, int pi, int vi, fpreal t) const
OP_API void OPcreateStickyNoteAboutCachedCode(OP_Network *subnet)
void evalStringInst(const UT_StringRef &name, const int *inst, UT_String &val, int vi, fpreal t, int nestlevel=1) const
OP_API bool OPisLegacyShaderParm(const PRM_Template &parm, OP_Node *owner)
fpreal64 fpreal
Definition: SYS_Types.h:277
std::weak_ptr< T > UT_WeakPtr
Definition: UT_WeakPtr.h:17
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
#define OP_API
Definition: OP_API.h:10
GLdouble GLdouble GLdouble r
Definition: glew.h:1406
GLuint GLfloat GLfloat GLfloat GLfloat y1
Definition: glew.h:12681
OP_API void OPwarnBadRefs(UT_WorkBuffer &msg, const UT_StringArray &badrefs)
SYS_FORCE_INLINE T & x()
Definition: UT_Vector3.h:511
UT_WeakPtr< PythonResultClient > WPtr
Definition: OP_Utils.h:429
GLuint64EXT * result
Definition: glew.h:14007
void updateRampFromMultiParm(fpreal t, const PRM_Parm &m, UT_Ramp &ramp, bool *time_dep=NULL, DEP_MicroNode *depnode=NULL) const
OP_API void registerPythonResultClient(PythonResultClient::WPtr result_client)
exint evalInt(int pi, int vi, fpreal t) const
exint evalIntInst(const UT_StringRef &name, const int *inst, int vi, fpreal t, int nestlevel=1) const
PRM_Parm * getParmPtrInst(const UT_StringRef &parm_name, const int *instance, int nest_level)
Definition: PRM_ParmList.h:455
SYS_FORCE_INLINE PRM_ParmList * getParmList()
Definition: PRM_ParmOwner.h:65
OP_API void OPgetItemBounds(fpreal &x1, fpreal &y1, fpreal &x2, fpreal &y2, const OP_NetworkBoxItemList &items)
OP_API bool OPcheckForVopnetsUsedOutside(OP_Node *node, OP_NodeList *badvopnets)
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:89