HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_CacheIf.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_API.h>
7 #include <SOP/SOP_NodeVerb.h>
8 #include <OP/OP_GraphProxy.h>
9 
10 #include <OP/OP_Utils.h>
11 #include <PRM/PRM_Parm.h>
12 #include <UT/UT_IStream.h>
13 #include <UT/UT_NTStreamUtil.h>
14 #include <UT/UT_Ramp.h>
15 #include <UT/UT_SharedPtr.h>
16 #include <UT/UT_StringHolder.h>
17 #include <UT/UT_StringStream.h>
18 #include <UT/UT_VectorTypes.h>
19 #include <UT/UT_EnvControl.h>
20 #include <SYS/SYS_Types.h>
21 
22 class DEP_MicroNode;
23 namespace SOP_CacheIfEnums
24 {
25  enum class CheckGroups
26  {
27  COOK = 0,
28  UPSTREAM
29  };
30 
31  SYS_FORCE_INLINE UT_StringHolder
32  getToken(CheckGroups enum_value)
33  {
34  using namespace UT::Literal;
35  switch (enum_value) {
36  case CheckGroups::COOK: return "cook"_sh;
37  case CheckGroups::UPSTREAM: return "upstream"_sh;
38  default: UT_ASSERT(false); return ""_sh;
39  }
40  }
41 
42  enum class Parm_GroupType
43  {
44  PRIMS = 0,
45  POINTS
46  };
47 
48  SYS_FORCE_INLINE UT_StringHolder
49  getToken(Parm_GroupType enum_value)
50  {
51  using namespace UT::Literal;
52  switch (enum_value) {
53  case Parm_GroupType::PRIMS: return "prims"_sh;
54  case Parm_GroupType::POINTS: return "points"_sh;
55  default: UT_ASSERT(false); return ""_sh;
56  }
57  }
58 
59  enum class Expr_CacheWhen
60  {
61  VALUE = 0,
62  CHANGE
63  };
64 
65  SYS_FORCE_INLINE UT_StringHolder
66  getToken(Expr_CacheWhen enum_value)
67  {
68  using namespace UT::Literal;
69  switch (enum_value) {
70  case Expr_CacheWhen::VALUE: return "value"_sh;
71  case Expr_CacheWhen::CHANGE: return "change"_sh;
72  default: UT_ASSERT(false); return ""_sh;
73  }
74  }
75 
76  enum class Expr_ExprType
77  {
78  FLT = 0,
79  STR
80  };
81 
82  SYS_FORCE_INLINE UT_StringHolder
83  getToken(Expr_ExprType enum_value)
84  {
85  using namespace UT::Literal;
86  switch (enum_value) {
87  case Expr_ExprType::FLT: return "flt"_sh;
88  case Expr_ExprType::STR: return "str"_sh;
89  default: UT_ASSERT(false); return ""_sh;
90  }
91  }
92 
93 }
94 
95 
96 class SOP_API SOP_CacheIfParms : public SOP_NodeParms
97 {
98 public:
99  static int version() { return 1; }
100  struct NumInputs
101  {
102  bool input_enable;
103  bool input_checkpointattribs;
104  UT_StringHolder input_pointattribs;
105  bool input_checkvertexattribs;
106  UT_StringHolder input_vertexattribs;
107  bool input_checkprimitiveattribs;
108  UT_StringHolder input_primitiveattribs;
109  bool input_checkdetailattribs;
110  UT_StringHolder input_detailattribs;
111  bool input_checkpointgroups;
112  UT_StringHolder input_pointgroups;
113  bool input_checkvertexgroups;
114  UT_StringHolder input_vertexgroups;
115  bool input_checkprimitivegroups;
116  UT_StringHolder input_primitivegroups;
117  bool input_checkedgegroups;
118  UT_StringHolder input_edgegroups;
119  bool input_checkdetailid;
120  bool input_checkprimitivesid;
121  bool input_checktopology;
122  bool input_checkchangecount;
123 
124 
125  NumInputs()
126  {
127  input_enable = true;
128  input_checkpointattribs = false;
129  input_pointattribs = ""_UTsh;
130  input_checkvertexattribs = false;
131  input_vertexattribs = ""_UTsh;
132  input_checkprimitiveattribs = false;
133  input_primitiveattribs = ""_UTsh;
134  input_checkdetailattribs = false;
135  input_detailattribs = ""_UTsh;
136  input_checkpointgroups = false;
137  input_pointgroups = ""_UTsh;
138  input_checkvertexgroups = false;
139  input_vertexgroups = ""_UTsh;
140  input_checkprimitivegroups = false;
141  input_primitivegroups = ""_UTsh;
142  input_checkedgegroups = false;
143  input_edgegroups = ""_UTsh;
144  input_checkdetailid = false;
145  input_checkprimitivesid = true;
146  input_checktopology = true;
147  input_checkchangecount = false;
148 
149  }
150 
151  bool operator==(const NumInputs &src) const
152  {
153  if (input_enable != src.input_enable) return false;
154  if (input_checkpointattribs != src.input_checkpointattribs) return false;
155  if (input_pointattribs != src.input_pointattribs) return false;
156  if (input_checkvertexattribs != src.input_checkvertexattribs) return false;
157  if (input_vertexattribs != src.input_vertexattribs) return false;
158  if (input_checkprimitiveattribs != src.input_checkprimitiveattribs) return false;
159  if (input_primitiveattribs != src.input_primitiveattribs) return false;
160  if (input_checkdetailattribs != src.input_checkdetailattribs) return false;
161  if (input_detailattribs != src.input_detailattribs) return false;
162  if (input_checkpointgroups != src.input_checkpointgroups) return false;
163  if (input_pointgroups != src.input_pointgroups) return false;
164  if (input_checkvertexgroups != src.input_checkvertexgroups) return false;
165  if (input_vertexgroups != src.input_vertexgroups) return false;
166  if (input_checkprimitivegroups != src.input_checkprimitivegroups) return false;
167  if (input_primitivegroups != src.input_primitivegroups) return false;
168  if (input_checkedgegroups != src.input_checkedgegroups) return false;
169  if (input_edgegroups != src.input_edgegroups) return false;
170  if (input_checkdetailid != src.input_checkdetailid) return false;
171  if (input_checkprimitivesid != src.input_checkprimitivesid) return false;
172  if (input_checktopology != src.input_checktopology) return false;
173  if (input_checkchangecount != src.input_checkchangecount) return false;
174 
175  return true;
176  }
177  bool operator!=(const NumInputs &src) const
178  {
179  return !operator==(src);
180  }
181 
182  };
183 
184  UT_StringHolder createString(const UT_Array<NumInputs> &list) const
185  {
186  UT_WorkBuffer buf;
187 
188  buf.strcat("[ ");
189  for (int i = 0; i < list.entries(); i++)
190  {
191  if (i)
192  buf.strcat(", ");
193  buf.strcat("( ");
194  buf.append("");
195  buf.appendSprintf("%s", (list(i).input_enable) ? "true" : "false");
196  buf.append(", ");
197  buf.appendSprintf("%s", (list(i).input_checkpointattribs) ? "true" : "false");
198  buf.append(", ");
199  { UT_String tmp; tmp = UT_StringWrap(list(i).input_pointattribs).makeQuotedString('"'); buf.strcat(tmp); }
200  buf.append(", ");
201  buf.appendSprintf("%s", (list(i).input_checkvertexattribs) ? "true" : "false");
202  buf.append(", ");
203  { UT_String tmp; tmp = UT_StringWrap(list(i).input_vertexattribs).makeQuotedString('"'); buf.strcat(tmp); }
204  buf.append(", ");
205  buf.appendSprintf("%s", (list(i).input_checkprimitiveattribs) ? "true" : "false");
206  buf.append(", ");
207  { UT_String tmp; tmp = UT_StringWrap(list(i).input_primitiveattribs).makeQuotedString('"'); buf.strcat(tmp); }
208  buf.append(", ");
209  buf.appendSprintf("%s", (list(i).input_checkdetailattribs) ? "true" : "false");
210  buf.append(", ");
211  { UT_String tmp; tmp = UT_StringWrap(list(i).input_detailattribs).makeQuotedString('"'); buf.strcat(tmp); }
212  buf.append(", ");
213  buf.appendSprintf("%s", (list(i).input_checkpointgroups) ? "true" : "false");
214  buf.append(", ");
215  { UT_String tmp; tmp = UT_StringWrap(list(i).input_pointgroups).makeQuotedString('"'); buf.strcat(tmp); }
216  buf.append(", ");
217  buf.appendSprintf("%s", (list(i).input_checkvertexgroups) ? "true" : "false");
218  buf.append(", ");
219  { UT_String tmp; tmp = UT_StringWrap(list(i).input_vertexgroups).makeQuotedString('"'); buf.strcat(tmp); }
220  buf.append(", ");
221  buf.appendSprintf("%s", (list(i).input_checkprimitivegroups) ? "true" : "false");
222  buf.append(", ");
223  { UT_String tmp; tmp = UT_StringWrap(list(i).input_primitivegroups).makeQuotedString('"'); buf.strcat(tmp); }
224  buf.append(", ");
225  buf.appendSprintf("%s", (list(i).input_checkedgegroups) ? "true" : "false");
226  buf.append(", ");
227  { UT_String tmp; tmp = UT_StringWrap(list(i).input_edgegroups).makeQuotedString('"'); buf.strcat(tmp); }
228  buf.append(", ");
229  buf.appendSprintf("%s", (list(i).input_checkdetailid) ? "true" : "false");
230  buf.append(", ");
231  buf.appendSprintf("%s", (list(i).input_checkprimitivesid) ? "true" : "false");
232  buf.append(", ");
233  buf.appendSprintf("%s", (list(i).input_checktopology) ? "true" : "false");
234  buf.append(", ");
235  buf.appendSprintf("%s", (list(i).input_checkchangecount) ? "true" : "false");
236 
237  buf.strcat(" )");
238  }
239  buf.strcat(" ]");
240 
241  UT_StringHolder result = buf;
242  return result;
243  }
244  struct NumPatterns
245  {
246  bool parm_enable;
247  UT_StringHolder parm_nodepath;
248  UT_StringHolder parm_parmfilter;
249  bool parm_expandmultiparms;
250  UT_StringHolder parm_groupfilter;
251  int64 parm_grouptype;
252  int64 parm_oninput;
253 
254 
255  NumPatterns()
256  {
257  parm_enable = true;
258  parm_nodepath = ""_UTsh;
259  parm_parmfilter = "*"_UTsh;
260  parm_expandmultiparms = true;
261  parm_groupfilter = ""_UTsh;
262  parm_grouptype = 1;
263  parm_oninput = 0;
264 
265  }
266 
267  bool operator==(const NumPatterns &src) const
268  {
269  if (parm_enable != src.parm_enable) return false;
270  if (parm_nodepath != src.parm_nodepath) return false;
271  if (parm_parmfilter != src.parm_parmfilter) return false;
272  if (parm_expandmultiparms != src.parm_expandmultiparms) return false;
273  if (parm_groupfilter != src.parm_groupfilter) return false;
274  if (parm_grouptype != src.parm_grouptype) return false;
275  if (parm_oninput != src.parm_oninput) return false;
276 
277  return true;
278  }
279  bool operator!=(const NumPatterns &src) const
280  {
281  return !operator==(src);
282  }
283 
284  };
285 
286  UT_StringHolder createString(const UT_Array<NumPatterns> &list) const
287  {
288  UT_WorkBuffer buf;
289 
290  buf.strcat("[ ");
291  for (int i = 0; i < list.entries(); i++)
292  {
293  if (i)
294  buf.strcat(", ");
295  buf.strcat("( ");
296  buf.append("");
297  buf.appendSprintf("%s", (list(i).parm_enable) ? "true" : "false");
298  buf.append(", ");
299  { UT_String tmp; tmp = UT_StringWrap(list(i).parm_nodepath).makeQuotedString('"'); buf.strcat(tmp); }
300  buf.append(", ");
301  { UT_String tmp; tmp = UT_StringWrap(list(i).parm_parmfilter).makeQuotedString('"'); buf.strcat(tmp); }
302  buf.append(", ");
303  buf.appendSprintf("%s", (list(i).parm_expandmultiparms) ? "true" : "false");
304  buf.append(", ");
305  { UT_String tmp; tmp = UT_StringWrap(list(i).parm_groupfilter).makeQuotedString('"'); buf.strcat(tmp); }
306  buf.append(", ");
307  buf.appendSprintf("%d", (int) list(i).parm_grouptype);
308  buf.append(", ");
309  buf.appendSprintf("%d", (int) list(i).parm_oninput);
310 
311  buf.strcat(" )");
312  }
313  buf.strcat(" ]");
314 
315  UT_StringHolder result = buf;
316  return result;
317  }
318  struct NumExpressions
319  {
320  bool expr_enable;
321  int64 expr_cachewhen;
322  int64 expr_exprval;
323  int64 expr_exprtype;
324  fpreal64 expr_numexpr;
325  UT_StringHolder expr_strexpr;
326 
327 
328  NumExpressions()
329  {
330  expr_enable = true;
331  expr_cachewhen = 0;
332  expr_exprval = 0;
333  expr_exprtype = 0;
334  expr_numexpr = 0;
335  expr_strexpr = ""_UTsh;
336 
337  }
338 
339  bool operator==(const NumExpressions &src) const
340  {
341  if (expr_enable != src.expr_enable) return false;
342  if (expr_cachewhen != src.expr_cachewhen) return false;
343  if (expr_exprval != src.expr_exprval) return false;
344  if (expr_exprtype != src.expr_exprtype) return false;
345  if (expr_numexpr != src.expr_numexpr) return false;
346  if (expr_strexpr != src.expr_strexpr) return false;
347 
348  return true;
349  }
350  bool operator!=(const NumExpressions &src) const
351  {
352  return !operator==(src);
353  }
354 
355  };
356 
357  UT_StringHolder createString(const UT_Array<NumExpressions> &list) const
358  {
359  UT_WorkBuffer buf;
360 
361  buf.strcat("[ ");
362  for (int i = 0; i < list.entries(); i++)
363  {
364  if (i)
365  buf.strcat(", ");
366  buf.strcat("( ");
367  buf.append("");
368  buf.appendSprintf("%s", (list(i).expr_enable) ? "true" : "false");
369  buf.append(", ");
370  buf.appendSprintf("%d", (int) list(i).expr_cachewhen);
371  buf.append(", ");
372  buf.appendSprintf("%d", (int) list(i).expr_exprval);
373  buf.append(", ");
374  buf.appendSprintf("%d", (int) list(i).expr_exprtype);
375  buf.append(", ");
376  buf.appendSprintf("%f", (list(i).expr_numexpr));
377  buf.append(", ");
378  { UT_String tmp; tmp = UT_StringWrap(list(i).expr_strexpr).makeQuotedString('"'); buf.strcat(tmp); }
379 
380  buf.strcat(" )");
381  }
382  buf.strcat(" ]");
383 
384  UT_StringHolder result = buf;
385  return result;
386  }
387 
388  SOP_CacheIfParms()
389  {
390  myCheckUpstream = false;
391  myOutputAttrib = false;
392  myCheckAttrib = false;
393  myAttribName = ""_UTsh;
394  myCheckGroups = 1;
395 
396  }
397 
398  explicit SOP_CacheIfParms(const SOP_CacheIfParms &) = default;
399  SOP_CacheIfParms &operator=(const SOP_CacheIfParms &) = default;
400  SOP_CacheIfParms(SOP_CacheIfParms &&) noexcept = default;
401  SOP_CacheIfParms &operator=(SOP_CacheIfParms &&) noexcept = default;
402 
403  ~SOP_CacheIfParms() override {}
404 
405  bool operator==(const SOP_CacheIfParms &src) const
406  {
407  if (myCheckUpstream != src.myCheckUpstream) return false;
408  if (myOutputAttrib != src.myOutputAttrib) return false;
409  if (myCheckAttrib != src.myCheckAttrib) return false;
410  if (myAttribName != src.myAttribName) return false;
411  if (myNumInputs != src.myNumInputs) return false;
412  if (myCheckGroups != src.myCheckGroups) return false;
413  if (myNumPatterns != src.myNumPatterns) return false;
414  if (myNumExpressions != src.myNumExpressions) return false;
415 
416 
417  if (baseGetSignature() != src.baseGetSignature()) return false;
418 
419  return true;
420  }
421  bool operator!=(const SOP_CacheIfParms &src) const
422  {
423  return !operator==(src);
424  }
425  using CheckGroups = SOP_CacheIfEnums::CheckGroups;
426  using Parm_GroupType = SOP_CacheIfEnums::Parm_GroupType;
427  using Expr_CacheWhen = SOP_CacheIfEnums::Expr_CacheWhen;
428  using Expr_ExprType = SOP_CacheIfEnums::Expr_ExprType;
429 
430 
431 
432  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
433  {
434  myCheckUpstream = false;
435  if (true)
436  graph->evalOpParm(myCheckUpstream, nodeidx, "checkupstream", time, graph->isDirect()?nullptr:depnode);
437  myOutputAttrib = false;
438  if (true)
439  graph->evalOpParm(myOutputAttrib, nodeidx, "outputattrib", time, graph->isDirect()?nullptr:depnode);
440  myCheckAttrib = false;
441  if (true)
442  graph->evalOpParm(myCheckAttrib, nodeidx, "checkattrib", time, graph->isDirect()?nullptr:depnode);
443  myAttribName = ""_UTsh;
444  if (true)
445  graph->evalOpParm(myAttribName, nodeidx, "attribname", time, graph->isDirect()?nullptr:depnode);
446  if (true)
447  {
448  int64 length = 0;
449  graph->evalOpParm(length, nodeidx, "numinputs", time, graph->isDirect()?nullptr:depnode);
450  if (length < 0) length = 0;
451  myNumInputs.setSize(length);
452  for (exint i = 0; i < length; i++)
453  {
454  int parmidx[1];
455  int offsets[1];
456  parmidx[0] = i+1;
457  offsets[0] = 1;
458  auto && _curentry = myNumInputs(i);
459  (void) _curentry;
460  _curentry.input_enable = true;
461  if (true)
462  graph->evalOpParmInst(_curentry.input_enable, nodeidx, "input_enable#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
463  _curentry.input_checkpointattribs = false;
464  if (true)
465  graph->evalOpParmInst(_curentry.input_checkpointattribs, nodeidx, "input_checkpointattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
466  _curentry.input_pointattribs = ""_UTsh;
467  if (true && ( (true&&!(((_curentry.input_checkpointattribs==0)))) ) )
468  graph->evalOpParmInst(_curentry.input_pointattribs, nodeidx, "input_pointattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
469  _curentry.input_checkvertexattribs = false;
470  if (true)
471  graph->evalOpParmInst(_curentry.input_checkvertexattribs, nodeidx, "input_checkvertexattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
472  _curentry.input_vertexattribs = ""_UTsh;
473  if (true && ( (true&&!(((_curentry.input_checkvertexattribs==0)))) ) )
474  graph->evalOpParmInst(_curentry.input_vertexattribs, nodeidx, "input_vertexattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
475  _curentry.input_checkprimitiveattribs = false;
476  if (true)
477  graph->evalOpParmInst(_curentry.input_checkprimitiveattribs, nodeidx, "input_checkprimitiveattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
478  _curentry.input_primitiveattribs = ""_UTsh;
479  if (true && ( (true&&!(((_curentry.input_checkprimitiveattribs==0)))) ) )
480  graph->evalOpParmInst(_curentry.input_primitiveattribs, nodeidx, "input_primitiveattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
481  _curentry.input_checkdetailattribs = false;
482  if (true)
483  graph->evalOpParmInst(_curentry.input_checkdetailattribs, nodeidx, "input_checkdetailattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
484  _curentry.input_detailattribs = ""_UTsh;
485  if (true && ( (true&&!(((_curentry.input_checkdetailattribs==0)))) ) )
486  graph->evalOpParmInst(_curentry.input_detailattribs, nodeidx, "input_detailattribs#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
487  _curentry.input_checkpointgroups = false;
488  if (true)
489  graph->evalOpParmInst(_curentry.input_checkpointgroups, nodeidx, "input_checkpointgroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
490  _curentry.input_pointgroups = ""_UTsh;
491  if (true && ( (true&&!(((_curentry.input_checkpointgroups==0)))) ) )
492  graph->evalOpParmInst(_curentry.input_pointgroups, nodeidx, "input_pointgroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
493  _curentry.input_checkvertexgroups = false;
494  if (true)
495  graph->evalOpParmInst(_curentry.input_checkvertexgroups, nodeidx, "input_checkvertexgroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
496  _curentry.input_vertexgroups = ""_UTsh;
497  if (true && ( (true&&!(((_curentry.input_checkvertexgroups==0)))) ) )
498  graph->evalOpParmInst(_curentry.input_vertexgroups, nodeidx, "input_vertexgroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
499  _curentry.input_checkprimitivegroups = false;
500  if (true)
501  graph->evalOpParmInst(_curentry.input_checkprimitivegroups, nodeidx, "input_checkprimitivegroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
502  _curentry.input_primitivegroups = ""_UTsh;
503  if (true && ( (true&&!(((_curentry.input_checkprimitivegroups==0)))) ) )
504  graph->evalOpParmInst(_curentry.input_primitivegroups, nodeidx, "input_primitivegroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
505  _curentry.input_checkedgegroups = false;
506  if (true)
507  graph->evalOpParmInst(_curentry.input_checkedgegroups, nodeidx, "input_checkedgegroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
508  _curentry.input_edgegroups = ""_UTsh;
509  if (true && ( (true&&!(((_curentry.input_checkedgegroups==0)))) ) )
510  graph->evalOpParmInst(_curentry.input_edgegroups, nodeidx, "input_edgegroups#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
511  _curentry.input_checkdetailid = false;
512  if (true)
513  graph->evalOpParmInst(_curentry.input_checkdetailid, nodeidx, "input_checkdetailid#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
514  _curentry.input_checkprimitivesid = true;
515  if (true)
516  graph->evalOpParmInst(_curentry.input_checkprimitivesid, nodeidx, "input_checkprimitivesid#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
517  _curentry.input_checktopology = true;
518  if (true)
519  graph->evalOpParmInst(_curentry.input_checktopology, nodeidx, "input_checktopology#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
520  _curentry.input_checkchangecount = false;
521  if (true)
522  graph->evalOpParmInst(_curentry.input_checkchangecount, nodeidx, "input_checkchangecount#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
523 
524  }
525  }
526  else
527  myNumInputs.clear();
528  myCheckGroups = 1;
529  if (true)
530  graph->evalOpParm(myCheckGroups, nodeidx, "checkgroups", time, graph->isDirect()?nullptr:depnode);
531  if (true)
532  {
533  int64 length = 0;
534  graph->evalOpParm(length, nodeidx, "numpatterns", time, graph->isDirect()?nullptr:depnode);
535  if (length < 0) length = 0;
536  myNumPatterns.setSize(length);
537  for (exint i = 0; i < length; i++)
538  {
539  int parmidx[1];
540  int offsets[1];
541  parmidx[0] = i+1;
542  offsets[0] = 1;
543  auto && _curentry = myNumPatterns(i);
544  (void) _curentry;
545  _curentry.parm_enable = true;
546  if (true)
547  graph->evalOpParmInst(_curentry.parm_enable, nodeidx, "parm_enable#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
548  _curentry.parm_nodepath = ""_UTsh;
549  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
550  graph->evalOpParmInst(_curentry.parm_nodepath, nodeidx, "parm_nodepath#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
551  _curentry.parm_parmfilter = "*"_UTsh;
552  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
553  graph->evalOpParmInst(_curentry.parm_parmfilter, nodeidx, "parm_parmfilter#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
554  _curentry.parm_expandmultiparms = true;
555  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
556  graph->evalOpParmInst(_curentry.parm_expandmultiparms, nodeidx, "parm_expandmultiparms#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
557  _curentry.parm_groupfilter = ""_UTsh;
558  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
559  graph->evalOpParmInst(_curentry.parm_groupfilter, nodeidx, "parm_groupfilter#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
560  _curentry.parm_grouptype = 1;
561  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
562  graph->evalOpParmInst(_curentry.parm_grouptype, nodeidx, "parm_grouptype#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
563  _curentry.parm_oninput = 0;
564  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
565  graph->evalOpParmInst(_curentry.parm_oninput, nodeidx, "parm_oninput#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
566 
567  }
568  }
569  else
570  myNumPatterns.clear();
571  if (true)
572  {
573  int64 length = 0;
574  graph->evalOpParm(length, nodeidx, "numexpressions", time, graph->isDirect()?nullptr:depnode);
575  if (length < 0) length = 0;
576  myNumExpressions.setSize(length);
577  for (exint i = 0; i < length; i++)
578  {
579  int parmidx[1];
580  int offsets[1];
581  parmidx[0] = i+1;
582  offsets[0] = 1;
583  auto && _curentry = myNumExpressions(i);
584  (void) _curentry;
585  _curentry.expr_enable = true;
586  if (true)
587  graph->evalOpParmInst(_curentry.expr_enable, nodeidx, "expr_enable#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
588  _curentry.expr_cachewhen = 0;
589  if (true && ( (true&&!(((_curentry.expr_enable==0)))) ) )
590  graph->evalOpParmInst(_curentry.expr_cachewhen, nodeidx, "expr_cachewhen#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
591  _curentry.expr_exprval = 0;
592  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=0)))) ) )
593  graph->evalOpParmInst(_curentry.expr_exprval, nodeidx, "expr_exprval#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
594  _curentry.expr_exprtype = 0;
595  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1)))) ) )
596  graph->evalOpParmInst(_curentry.expr_exprtype, nodeidx, "expr_exprtype#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
597  _curentry.expr_numexpr = 0;
598  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1))||((_curentry.expr_exprtype!=0)))) ) )
599  graph->evalOpParmInst(_curentry.expr_numexpr, nodeidx, "expr_numexpr#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
600  _curentry.expr_strexpr = ""_UTsh;
601  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1))||((_curentry.expr_exprtype!=1)))) ) )
602  graph->evalOpParmInst(_curentry.expr_strexpr, nodeidx, "expr_strexpr#", parmidx, offsets, time, graph->isDirect()?nullptr:depnode, 2-1);
603 
604  }
605  }
606  else
607  myNumExpressions.clear();
608 
609  }
610 
611 
612  void loadFromOpSubclass(const LoadParms &loadparms) override
613  {
614  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
615  }
616 
617 
618  void copyFrom(const OP_NodeParms *src) override
619  {
620  *this = *((const SOP_CacheIfParms *)src);
621  }
622 
623  template <typename T>
624  void
625  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
626  {
627  if (idx.size() < 1)
628  return;
629  UT_ASSERT(idx.size() == instance.size()+1);
630  if (idx.size() != instance.size()+1)
631  return;
632  switch (idx[0])
633  {
634  case 0:
635  coerceValue(value, myCheckUpstream);
636  break;
637  case 1:
638  coerceValue(value, myOutputAttrib);
639  break;
640  case 2:
641  coerceValue(value, myCheckAttrib);
642  break;
643  case 3:
644  coerceValue(value, myAttribName);
645  break;
646  case 4:
647  if (idx.size() == 1)
648  coerceValue(value, myNumInputs.entries());
649  else if (instance[0] < myNumInputs.entries())
650  {
651  auto && _data = myNumInputs(instance[0]);
652  switch (idx[1])
653  {
654  case 0:
655  coerceValue(value, _data.input_enable);
656  break;
657  case 1:
658  coerceValue(value, _data.input_checkpointattribs);
659  break;
660  case 2:
661  coerceValue(value, _data.input_pointattribs);
662  break;
663  case 3:
664  coerceValue(value, _data.input_checkvertexattribs);
665  break;
666  case 4:
667  coerceValue(value, _data.input_vertexattribs);
668  break;
669  case 5:
670  coerceValue(value, _data.input_checkprimitiveattribs);
671  break;
672  case 6:
673  coerceValue(value, _data.input_primitiveattribs);
674  break;
675  case 7:
676  coerceValue(value, _data.input_checkdetailattribs);
677  break;
678  case 8:
679  coerceValue(value, _data.input_detailattribs);
680  break;
681  case 9:
682  coerceValue(value, _data.input_checkpointgroups);
683  break;
684  case 10:
685  coerceValue(value, _data.input_pointgroups);
686  break;
687  case 11:
688  coerceValue(value, _data.input_checkvertexgroups);
689  break;
690  case 12:
691  coerceValue(value, _data.input_vertexgroups);
692  break;
693  case 13:
694  coerceValue(value, _data.input_checkprimitivegroups);
695  break;
696  case 14:
697  coerceValue(value, _data.input_primitivegroups);
698  break;
699  case 15:
700  coerceValue(value, _data.input_checkedgegroups);
701  break;
702  case 16:
703  coerceValue(value, _data.input_edgegroups);
704  break;
705  case 17:
706  coerceValue(value, _data.input_checkdetailid);
707  break;
708  case 18:
709  coerceValue(value, _data.input_checkprimitivesid);
710  break;
711  case 19:
712  coerceValue(value, _data.input_checktopology);
713  break;
714  case 20:
715  coerceValue(value, _data.input_checkchangecount);
716  break;
717 
718  }
719  }
720  break;
721  case 5:
722  coerceValue(value, myCheckGroups);
723  break;
724  case 6:
725  if (idx.size() == 1)
726  coerceValue(value, myNumPatterns.entries());
727  else if (instance[0] < myNumPatterns.entries())
728  {
729  auto && _data = myNumPatterns(instance[0]);
730  switch (idx[1])
731  {
732  case 0:
733  coerceValue(value, _data.parm_enable);
734  break;
735  case 1:
736  coerceValue(value, _data.parm_nodepath);
737  break;
738  case 2:
739  coerceValue(value, _data.parm_parmfilter);
740  break;
741  case 3:
742  coerceValue(value, _data.parm_expandmultiparms);
743  break;
744  case 4:
745  coerceValue(value, _data.parm_groupfilter);
746  break;
747  case 5:
748  coerceValue(value, _data.parm_grouptype);
749  break;
750  case 6:
751  coerceValue(value, _data.parm_oninput);
752  break;
753 
754  }
755  }
756  break;
757  case 7:
758  if (idx.size() == 1)
759  coerceValue(value, myNumExpressions.entries());
760  else if (instance[0] < myNumExpressions.entries())
761  {
762  auto && _data = myNumExpressions(instance[0]);
763  switch (idx[1])
764  {
765  case 0:
766  coerceValue(value, _data.expr_enable);
767  break;
768  case 1:
769  coerceValue(value, _data.expr_cachewhen);
770  break;
771  case 2:
772  coerceValue(value, _data.expr_exprval);
773  break;
774  case 3:
775  coerceValue(value, _data.expr_exprtype);
776  break;
777  case 4:
778  coerceValue(value, _data.expr_numexpr);
779  break;
780  case 5:
781  coerceValue(value, _data.expr_strexpr);
782  break;
783 
784  }
785  }
786  break;
787 
788  }
789  }
790 
791  bool isParmColorRamp(exint idx) const override
792  {
793  switch (idx)
794  {
795 
796  }
797  return false;
798  }
799 
800  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
801  { doGetParmValue(idx, instance, value); }
802  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
803  { doGetParmValue(idx, instance, value); }
804  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
805  { doGetParmValue(idx, instance, value); }
806  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
807  { doGetParmValue(idx, instance, value); }
808  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
809  { doGetParmValue(idx, instance, value); }
810  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
811  { doGetParmValue(idx, instance, value); }
812  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
813  { doGetParmValue(idx, instance, value); }
814  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
815  { doGetParmValue(idx, instance, value); }
816  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
817  { doGetParmValue(idx, instance, value); }
818  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
819  { doGetParmValue(idx, instance, value); }
820  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
821  { doGetParmValue(idx, instance, value); }
822 
823  template <typename T>
824  void
825  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
826  {
827  if (idx.size() < 1)
828  return;
829  UT_ASSERT(idx.size() == instance.size()+1);
830  if (idx.size() != instance.size()+1)
831  return;
832  switch (idx[0])
833  {
834  case 0:
835  coerceValue(myCheckUpstream, ( ( value ) ));
836  break;
837  case 1:
838  coerceValue(myOutputAttrib, ( ( value ) ));
839  break;
840  case 2:
841  coerceValue(myCheckAttrib, ( ( value ) ));
842  break;
843  case 3:
844  coerceValue(myAttribName, ( ( value ) ));
845  break;
846  case 4:
847  if (idx.size() == 1)
848  {
849  exint newsize;
850  coerceValue(newsize, value);
851  if (newsize < 0) newsize = 0;
852  myNumInputs.setSize(newsize);
853  }
854  else
855  {
856  if (instance[0] < 0)
857  return;
858  myNumInputs.setSizeIfNeeded(instance[0]+1);
859  auto && _data = myNumInputs(instance[0]);
860  switch (idx[1])
861  {
862  case 0:
863  coerceValue(_data.input_enable, value);
864  break;
865  case 1:
866  coerceValue(_data.input_checkpointattribs, value);
867  break;
868  case 2:
869  coerceValue(_data.input_pointattribs, value);
870  break;
871  case 3:
872  coerceValue(_data.input_checkvertexattribs, value);
873  break;
874  case 4:
875  coerceValue(_data.input_vertexattribs, value);
876  break;
877  case 5:
878  coerceValue(_data.input_checkprimitiveattribs, value);
879  break;
880  case 6:
881  coerceValue(_data.input_primitiveattribs, value);
882  break;
883  case 7:
884  coerceValue(_data.input_checkdetailattribs, value);
885  break;
886  case 8:
887  coerceValue(_data.input_detailattribs, value);
888  break;
889  case 9:
890  coerceValue(_data.input_checkpointgroups, value);
891  break;
892  case 10:
893  coerceValue(_data.input_pointgroups, value);
894  break;
895  case 11:
896  coerceValue(_data.input_checkvertexgroups, value);
897  break;
898  case 12:
899  coerceValue(_data.input_vertexgroups, value);
900  break;
901  case 13:
902  coerceValue(_data.input_checkprimitivegroups, value);
903  break;
904  case 14:
905  coerceValue(_data.input_primitivegroups, value);
906  break;
907  case 15:
908  coerceValue(_data.input_checkedgegroups, value);
909  break;
910  case 16:
911  coerceValue(_data.input_edgegroups, value);
912  break;
913  case 17:
914  coerceValue(_data.input_checkdetailid, value);
915  break;
916  case 18:
917  coerceValue(_data.input_checkprimitivesid, value);
918  break;
919  case 19:
920  coerceValue(_data.input_checktopology, value);
921  break;
922  case 20:
923  coerceValue(_data.input_checkchangecount, value);
924  break;
925 
926  }
927  }
928  break;
929  case 5:
930  coerceValue(myCheckGroups, clampMinValue(0, clampMaxValue(1, value ) ));
931  break;
932  case 6:
933  if (idx.size() == 1)
934  {
935  exint newsize;
936  coerceValue(newsize, value);
937  if (newsize < 0) newsize = 0;
938  myNumPatterns.setSize(newsize);
939  }
940  else
941  {
942  if (instance[0] < 0)
943  return;
944  myNumPatterns.setSizeIfNeeded(instance[0]+1);
945  auto && _data = myNumPatterns(instance[0]);
946  switch (idx[1])
947  {
948  case 0:
949  coerceValue(_data.parm_enable, value);
950  break;
951  case 1:
952  coerceValue(_data.parm_nodepath, value);
953  break;
954  case 2:
955  coerceValue(_data.parm_parmfilter, value);
956  break;
957  case 3:
958  coerceValue(_data.parm_expandmultiparms, value);
959  break;
960  case 4:
961  coerceValue(_data.parm_groupfilter, value);
962  break;
963  case 5:
964  coerceValue(_data.parm_grouptype, value);
965  break;
966  case 6:
967  coerceValue(_data.parm_oninput, value);
968  break;
969 
970  }
971  }
972  break;
973  case 7:
974  if (idx.size() == 1)
975  {
976  exint newsize;
977  coerceValue(newsize, value);
978  if (newsize < 0) newsize = 0;
979  myNumExpressions.setSize(newsize);
980  }
981  else
982  {
983  if (instance[0] < 0)
984  return;
985  myNumExpressions.setSizeIfNeeded(instance[0]+1);
986  auto && _data = myNumExpressions(instance[0]);
987  switch (idx[1])
988  {
989  case 0:
990  coerceValue(_data.expr_enable, value);
991  break;
992  case 1:
993  coerceValue(_data.expr_cachewhen, value);
994  break;
995  case 2:
996  coerceValue(_data.expr_exprval, value);
997  break;
998  case 3:
999  coerceValue(_data.expr_exprtype, value);
1000  break;
1001  case 4:
1002  coerceValue(_data.expr_numexpr, value);
1003  break;
1004  case 5:
1005  coerceValue(_data.expr_strexpr, value);
1006  break;
1007 
1008  }
1009  }
1010  break;
1011 
1012  }
1013  }
1014 
1015  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
1016  { doSetParmValue(idx, instance, value); }
1017  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
1018  { doSetParmValue(idx, instance, value); }
1019  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
1020  { doSetParmValue(idx, instance, value); }
1021  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
1022  { doSetParmValue(idx, instance, value); }
1023  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
1024  { doSetParmValue(idx, instance, value); }
1025  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
1026  { doSetParmValue(idx, instance, value); }
1027  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
1028  { doSetParmValue(idx, instance, value); }
1029  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
1030  { doSetParmValue(idx, instance, value); }
1031  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
1032  { doSetParmValue(idx, instance, value); }
1033  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
1034  { doSetParmValue(idx, instance, value); }
1035  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
1036  { doSetParmValue(idx, instance, value); }
1037 
1038  exint getNestNumParms(TempIndex idx) const override
1039  {
1040  if (idx.size() == 0)
1041  return 8;
1042  switch (idx[0])
1043  {
1044  case 4:
1045  return 21;
1046  case 6:
1047  return 7;
1048  case 7:
1049  return 6;
1050 
1051  }
1052  // Invalid
1053  return 0;
1054  }
1055 
1056  const char *getNestParmName(TempIndex fieldnum) const override
1057  {
1058  if (fieldnum.size() < 1)
1059  return 0;
1060  switch (fieldnum[0])
1061  {
1062  case 0:
1063  return "checkupstream";
1064  case 1:
1065  return "outputattrib";
1066  case 2:
1067  return "checkattrib";
1068  case 3:
1069  return "attribname";
1070  case 4:
1071  if (fieldnum.size() == 1)
1072  return "numinputs";
1073  switch (fieldnum[1])
1074  {
1075  case 0:
1076  return "input_enable#";
1077  case 1:
1078  return "input_checkpointattribs#";
1079  case 2:
1080  return "input_pointattribs#";
1081  case 3:
1082  return "input_checkvertexattribs#";
1083  case 4:
1084  return "input_vertexattribs#";
1085  case 5:
1086  return "input_checkprimitiveattribs#";
1087  case 6:
1088  return "input_primitiveattribs#";
1089  case 7:
1090  return "input_checkdetailattribs#";
1091  case 8:
1092  return "input_detailattribs#";
1093  case 9:
1094  return "input_checkpointgroups#";
1095  case 10:
1096  return "input_pointgroups#";
1097  case 11:
1098  return "input_checkvertexgroups#";
1099  case 12:
1100  return "input_vertexgroups#";
1101  case 13:
1102  return "input_checkprimitivegroups#";
1103  case 14:
1104  return "input_primitivegroups#";
1105  case 15:
1106  return "input_checkedgegroups#";
1107  case 16:
1108  return "input_edgegroups#";
1109  case 17:
1110  return "input_checkdetailid#";
1111  case 18:
1112  return "input_checkprimitivesid#";
1113  case 19:
1114  return "input_checktopology#";
1115  case 20:
1116  return "input_checkchangecount#";
1117 
1118  }
1119  return 0;
1120  case 5:
1121  return "checkgroups";
1122  case 6:
1123  if (fieldnum.size() == 1)
1124  return "numpatterns";
1125  switch (fieldnum[1])
1126  {
1127  case 0:
1128  return "parm_enable#";
1129  case 1:
1130  return "parm_nodepath#";
1131  case 2:
1132  return "parm_parmfilter#";
1133  case 3:
1134  return "parm_expandmultiparms#";
1135  case 4:
1136  return "parm_groupfilter#";
1137  case 5:
1138  return "parm_grouptype#";
1139  case 6:
1140  return "parm_oninput#";
1141 
1142  }
1143  return 0;
1144  case 7:
1145  if (fieldnum.size() == 1)
1146  return "numexpressions";
1147  switch (fieldnum[1])
1148  {
1149  case 0:
1150  return "expr_enable#";
1151  case 1:
1152  return "expr_cachewhen#";
1153  case 2:
1154  return "expr_exprval#";
1155  case 3:
1156  return "expr_exprtype#";
1157  case 4:
1158  return "expr_numexpr#";
1159  case 5:
1160  return "expr_strexpr#";
1161 
1162  }
1163  return 0;
1164 
1165  }
1166  return 0;
1167  }
1168 
1169  ParmType getNestParmType(TempIndex fieldnum) const override
1170  {
1171  if (fieldnum.size() < 1)
1172  return PARM_UNSUPPORTED;
1173  switch (fieldnum[0])
1174  {
1175  case 0:
1176  return PARM_INTEGER;
1177  case 1:
1178  return PARM_INTEGER;
1179  case 2:
1180  return PARM_INTEGER;
1181  case 3:
1182  return PARM_STRING;
1183  case 4:
1184  if (fieldnum.size() == 1)
1185  return PARM_MULTIPARM;
1186  switch (fieldnum[1])
1187  {
1188  case 0:
1189  return PARM_INTEGER;
1190  case 1:
1191  return PARM_INTEGER;
1192  case 2:
1193  return PARM_STRING;
1194  case 3:
1195  return PARM_INTEGER;
1196  case 4:
1197  return PARM_STRING;
1198  case 5:
1199  return PARM_INTEGER;
1200  case 6:
1201  return PARM_STRING;
1202  case 7:
1203  return PARM_INTEGER;
1204  case 8:
1205  return PARM_STRING;
1206  case 9:
1207  return PARM_INTEGER;
1208  case 10:
1209  return PARM_STRING;
1210  case 11:
1211  return PARM_INTEGER;
1212  case 12:
1213  return PARM_STRING;
1214  case 13:
1215  return PARM_INTEGER;
1216  case 14:
1217  return PARM_STRING;
1218  case 15:
1219  return PARM_INTEGER;
1220  case 16:
1221  return PARM_STRING;
1222  case 17:
1223  return PARM_INTEGER;
1224  case 18:
1225  return PARM_INTEGER;
1226  case 19:
1227  return PARM_INTEGER;
1228  case 20:
1229  return PARM_INTEGER;
1230 
1231  }
1232  return PARM_UNSUPPORTED;
1233  case 5:
1234  return PARM_INTEGER;
1235  case 6:
1236  if (fieldnum.size() == 1)
1237  return PARM_MULTIPARM;
1238  switch (fieldnum[1])
1239  {
1240  case 0:
1241  return PARM_INTEGER;
1242  case 1:
1243  return PARM_STRING;
1244  case 2:
1245  return PARM_STRING;
1246  case 3:
1247  return PARM_INTEGER;
1248  case 4:
1249  return PARM_STRING;
1250  case 5:
1251  return PARM_INTEGER;
1252  case 6:
1253  return PARM_INTEGER;
1254 
1255  }
1256  return PARM_UNSUPPORTED;
1257  case 7:
1258  if (fieldnum.size() == 1)
1259  return PARM_MULTIPARM;
1260  switch (fieldnum[1])
1261  {
1262  case 0:
1263  return PARM_INTEGER;
1264  case 1:
1265  return PARM_INTEGER;
1266  case 2:
1267  return PARM_INTEGER;
1268  case 3:
1269  return PARM_INTEGER;
1270  case 4:
1271  return PARM_FLOAT;
1272  case 5:
1273  return PARM_STRING;
1274 
1275  }
1276  return PARM_UNSUPPORTED;
1277 
1278  }
1279  return PARM_UNSUPPORTED;
1280  }
1281 
1282  // Boiler plate to load individual types.
1283  static void loadData(UT_IStream &is, int64 &v)
1284  { is.bread(&v, 1); }
1285  static void loadData(UT_IStream &is, bool &v)
1286  { int64 iv; is.bread(&iv, 1); v = iv; }
1287  static void loadData(UT_IStream &is, fpreal64 &v)
1288  { is.bread<fpreal64>(&v, 1); }
1289  static void loadData(UT_IStream &is, UT_Vector2D &v)
1290  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1291  static void loadData(UT_IStream &is, UT_Vector3D &v)
1292  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1293  is.bread<fpreal64>(&v.z(), 1); }
1294  static void loadData(UT_IStream &is, UT_Vector4D &v)
1295  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1296  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1297  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1298  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1299  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1300  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1301  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1302  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1303  static void loadData(UT_IStream &is, UT_Vector2I &v)
1304  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1305  static void loadData(UT_IStream &is, UT_Vector3I &v)
1306  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1307  is.bread<int64>(&v.z(), 1); }
1308  static void loadData(UT_IStream &is, UT_Vector4I &v)
1309  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1310  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1311  static void loadData(UT_IStream &is, UT_StringHolder &v)
1312  { is.bread(v); }
1313  static void loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
1314  { UT_StringHolder rampdata;
1315  loadData(is, rampdata);
1316  if (rampdata.isstring())
1317  {
1318  v.reset(new UT_Ramp());
1319  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1320  v->load(istr);
1321  }
1322  else v.reset();
1323  }
1324  static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
1325  { UT_StringHolder data;
1326  loadData(is, data);
1327  if (data.isstring())
1328  {
1329  // Find the data type.
1330  const char *colon = UT_StringWrap(data).findChar(':');
1331  if (colon)
1332  {
1333  int typelen = colon - data.buffer();
1334  UT_WorkBuffer type;
1335  type.strncpy(data.buffer(), typelen);
1336  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1337 
1338  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1339  }
1340  }
1341  else v.reset();
1342  }
1343 
1344  static void saveData(std::ostream &os, int64 v)
1345  { UTwrite(os, &v); }
1346  static void saveData(std::ostream &os, bool v)
1347  { int64 iv = v; UTwrite(os, &iv); }
1348  static void saveData(std::ostream &os, fpreal64 v)
1349  { UTwrite<fpreal64>(os, &v); }
1350  static void saveData(std::ostream &os, UT_Vector2D v)
1351  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1352  static void saveData(std::ostream &os, UT_Vector3D v)
1353  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1354  UTwrite<fpreal64>(os, &v.z()); }
1355  static void saveData(std::ostream &os, UT_Vector4D v)
1356  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1357  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1358  static void saveData(std::ostream &os, UT_Matrix2D v)
1359  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1360  static void saveData(std::ostream &os, UT_Matrix3D v)
1361  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1362  static void saveData(std::ostream &os, UT_Matrix4D v)
1363  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1364  static void saveData(std::ostream &os, UT_StringHolder s)
1365  { UT_StringWrap(s).saveBinary(os); }
1366  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1367  { UT_StringHolder result;
1368  UT_OStringStream ostr;
1369  if (s) s->save(ostr);
1370  result = ostr.str();
1371  saveData(os, result);
1372  }
1373  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1374  { UT_StringHolder result;
1375  UT_OStringStream ostr;
1376  if (s)
1377  {
1378  ostr << s->getDataTypeToken();
1379  ostr << ":";
1380  s->saveBinary(ostr);
1381  }
1382  result = ostr.str();
1383  saveData(os, result);
1384  }
1385 
1386 
1387  void save(std::ostream &os) const
1388  {
1389  int32 v = version();
1390  UTwrite(os, &v);
1391  saveData(os, myCheckUpstream);
1392  saveData(os, myOutputAttrib);
1393  saveData(os, myCheckAttrib);
1394  saveData(os, myAttribName);
1395  {
1396  int64 length = myNumInputs.entries();
1397  UTwrite(os, &length);
1398  for (exint i = 0; i < length; i++)
1399  {
1400  auto && _curentry = myNumInputs(i);
1401  (void) _curentry;
1402  saveData(os, _curentry.input_enable);
1403  saveData(os, _curentry.input_checkpointattribs);
1404  saveData(os, _curentry.input_pointattribs);
1405  saveData(os, _curentry.input_checkvertexattribs);
1406  saveData(os, _curentry.input_vertexattribs);
1407  saveData(os, _curentry.input_checkprimitiveattribs);
1408  saveData(os, _curentry.input_primitiveattribs);
1409  saveData(os, _curentry.input_checkdetailattribs);
1410  saveData(os, _curentry.input_detailattribs);
1411  saveData(os, _curentry.input_checkpointgroups);
1412  saveData(os, _curentry.input_pointgroups);
1413  saveData(os, _curentry.input_checkvertexgroups);
1414  saveData(os, _curentry.input_vertexgroups);
1415  saveData(os, _curentry.input_checkprimitivegroups);
1416  saveData(os, _curentry.input_primitivegroups);
1417  saveData(os, _curentry.input_checkedgegroups);
1418  saveData(os, _curentry.input_edgegroups);
1419  saveData(os, _curentry.input_checkdetailid);
1420  saveData(os, _curentry.input_checkprimitivesid);
1421  saveData(os, _curentry.input_checktopology);
1422  saveData(os, _curentry.input_checkchangecount);
1423 
1424  }
1425  }
1426  saveData(os, myCheckGroups);
1427  {
1428  int64 length = myNumPatterns.entries();
1429  UTwrite(os, &length);
1430  for (exint i = 0; i < length; i++)
1431  {
1432  auto && _curentry = myNumPatterns(i);
1433  (void) _curentry;
1434  saveData(os, _curentry.parm_enable);
1435  saveData(os, _curentry.parm_nodepath);
1436  saveData(os, _curentry.parm_parmfilter);
1437  saveData(os, _curentry.parm_expandmultiparms);
1438  saveData(os, _curentry.parm_groupfilter);
1439  saveData(os, _curentry.parm_grouptype);
1440  saveData(os, _curentry.parm_oninput);
1441 
1442  }
1443  }
1444  {
1445  int64 length = myNumExpressions.entries();
1446  UTwrite(os, &length);
1447  for (exint i = 0; i < length; i++)
1448  {
1449  auto && _curentry = myNumExpressions(i);
1450  (void) _curentry;
1451  saveData(os, _curentry.expr_enable);
1452  saveData(os, _curentry.expr_cachewhen);
1453  saveData(os, _curentry.expr_exprval);
1454  saveData(os, _curentry.expr_exprtype);
1455  saveData(os, _curentry.expr_numexpr);
1456  saveData(os, _curentry.expr_strexpr);
1457 
1458  }
1459  }
1460 
1461  }
1462 
1463  bool load(UT_IStream &is)
1464  {
1465  int32 v;
1466  is.bread(&v, 1);
1467  if (version() != v)
1468  {
1469  // Fail incompatible versions
1470  return false;
1471  }
1472  loadData(is, myCheckUpstream);
1473  loadData(is, myOutputAttrib);
1474  loadData(is, myCheckAttrib);
1475  loadData(is, myAttribName);
1476  {
1477  int64 length;
1478  is.read(&length, 1);
1479  myNumInputs.setSize(length);
1480  for (exint i = 0; i < length; i++)
1481  {
1482  auto && _curentry = myNumInputs(i);
1483  (void) _curentry;
1484  loadData(is, _curentry.input_enable);
1485  loadData(is, _curentry.input_checkpointattribs);
1486  loadData(is, _curentry.input_pointattribs);
1487  loadData(is, _curentry.input_checkvertexattribs);
1488  loadData(is, _curentry.input_vertexattribs);
1489  loadData(is, _curentry.input_checkprimitiveattribs);
1490  loadData(is, _curentry.input_primitiveattribs);
1491  loadData(is, _curentry.input_checkdetailattribs);
1492  loadData(is, _curentry.input_detailattribs);
1493  loadData(is, _curentry.input_checkpointgroups);
1494  loadData(is, _curentry.input_pointgroups);
1495  loadData(is, _curentry.input_checkvertexgroups);
1496  loadData(is, _curentry.input_vertexgroups);
1497  loadData(is, _curentry.input_checkprimitivegroups);
1498  loadData(is, _curentry.input_primitivegroups);
1499  loadData(is, _curentry.input_checkedgegroups);
1500  loadData(is, _curentry.input_edgegroups);
1501  loadData(is, _curentry.input_checkdetailid);
1502  loadData(is, _curentry.input_checkprimitivesid);
1503  loadData(is, _curentry.input_checktopology);
1504  loadData(is, _curentry.input_checkchangecount);
1505 
1506  }
1507  }
1508  loadData(is, myCheckGroups);
1509  {
1510  int64 length;
1511  is.read(&length, 1);
1512  myNumPatterns.setSize(length);
1513  for (exint i = 0; i < length; i++)
1514  {
1515  auto && _curentry = myNumPatterns(i);
1516  (void) _curentry;
1517  loadData(is, _curentry.parm_enable);
1518  loadData(is, _curentry.parm_nodepath);
1519  loadData(is, _curentry.parm_parmfilter);
1520  loadData(is, _curentry.parm_expandmultiparms);
1521  loadData(is, _curentry.parm_groupfilter);
1522  loadData(is, _curentry.parm_grouptype);
1523  loadData(is, _curentry.parm_oninput);
1524 
1525  }
1526  }
1527  {
1528  int64 length;
1529  is.read(&length, 1);
1530  myNumExpressions.setSize(length);
1531  for (exint i = 0; i < length; i++)
1532  {
1533  auto && _curentry = myNumExpressions(i);
1534  (void) _curentry;
1535  loadData(is, _curentry.expr_enable);
1536  loadData(is, _curentry.expr_cachewhen);
1537  loadData(is, _curentry.expr_exprval);
1538  loadData(is, _curentry.expr_exprtype);
1539  loadData(is, _curentry.expr_numexpr);
1540  loadData(is, _curentry.expr_strexpr);
1541 
1542  }
1543  }
1544 
1545  return true;
1546  }
1547 
1548  bool getCheckUpstream() const { return myCheckUpstream; }
1549  void setCheckUpstream(bool val) { myCheckUpstream = val; }
1550  bool opCheckUpstream(const SOP_NodeVerb::CookParms &cookparms) const
1551  {
1552  SOP_Node *thissop = cookparms.getNode();
1553  if (!thissop) return getCheckUpstream();
1554  bool result;
1555  OP_Utils::evalOpParm(result, thissop, "checkupstream", cookparms.getCookTime(), 0);
1556  return result;
1557  }
1558  bool getOutputAttrib() const { return myOutputAttrib; }
1559  void setOutputAttrib(bool val) { myOutputAttrib = val; }
1560  bool opOutputAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1561  {
1562  SOP_Node *thissop = cookparms.getNode();
1563  if (!thissop) return getOutputAttrib();
1564  bool result;
1565  OP_Utils::evalOpParm(result, thissop, "outputattrib", cookparms.getCookTime(), 0);
1566  return result;
1567  }
1568  bool getCheckAttrib() const { return myCheckAttrib; }
1569  void setCheckAttrib(bool val) { myCheckAttrib = val; }
1570  bool opCheckAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1571  {
1572  SOP_Node *thissop = cookparms.getNode();
1573  if (!thissop) return getCheckAttrib();
1574  bool result;
1575  OP_Utils::evalOpParm(result, thissop, "checkattrib", cookparms.getCookTime(), 0);
1576  return result;
1577  }
1578  const UT_StringHolder & getAttribName() const { return myAttribName; }
1579  void setAttribName(const UT_StringHolder & val) { myAttribName = val; }
1580  UT_StringHolder opAttribName(const SOP_NodeVerb::CookParms &cookparms) const
1581  {
1582  SOP_Node *thissop = cookparms.getNode();
1583  if (!thissop) return getAttribName();
1584  UT_StringHolder result;
1585  OP_Utils::evalOpParm(result, thissop, "attribname", cookparms.getCookTime(), 0);
1586  return result;
1587  }
1588  const UT_Array<NumInputs> &getNumInputs() const { return myNumInputs; }
1589 void setNumInputs(const UT_Array<NumInputs> &val) { myNumInputs = val; }
1590  exint opNumInputs(const SOP_NodeVerb::CookParms &cookparms) const
1591  {
1592  SOP_Node *thissop = cookparms.getNode();
1593  if (!thissop) return getNumInputs().entries();
1594  exint result;
1595  OP_Utils::evalOpParm(result, thissop, "numinputs", cookparms.getCookTime(), 0);
1596  return result;
1597  }
1598  bool opNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1599  { return opinstNumInputs_input_enable(cookparms, &_idx); }
1600  bool opinstNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1601  {
1602  SOP_Node *thissop = cookparms.getNode();
1603  if (!thissop) return (myNumInputs(_idx[0]).input_enable);
1604  int _parmidx[2-1];
1605  _parmidx[1-1] = _idx[1-1] + 1;
1606 
1607  bool result;
1608  OP_Utils::evalOpParmInst(result, thissop, "input_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1609  return (result);
1610  }
1611  bool opNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1612  { return opinstNumInputs_input_checkpointattribs(cookparms, &_idx); }
1613  bool opinstNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1614  {
1615  SOP_Node *thissop = cookparms.getNode();
1616  if (!thissop) return (myNumInputs(_idx[0]).input_checkpointattribs);
1617  int _parmidx[2-1];
1618  _parmidx[1-1] = _idx[1-1] + 1;
1619 
1620  bool result;
1621  OP_Utils::evalOpParmInst(result, thissop, "input_checkpointattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1622  return (result);
1623  }
1624  UT_StringHolder opNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1625  { return opinstNumInputs_input_pointattribs(cookparms, &_idx); }
1626  UT_StringHolder opinstNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1627  {
1628  SOP_Node *thissop = cookparms.getNode();
1629  if (!thissop) return (myNumInputs(_idx[0]).input_pointattribs);
1630  int _parmidx[2-1];
1631  _parmidx[1-1] = _idx[1-1] + 1;
1632 
1633  UT_StringHolder result;
1634  OP_Utils::evalOpParmInst(result, thissop, "input_pointattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1635  return (result);
1636  }
1637  bool opNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1638  { return opinstNumInputs_input_checkvertexattribs(cookparms, &_idx); }
1639  bool opinstNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1640  {
1641  SOP_Node *thissop = cookparms.getNode();
1642  if (!thissop) return (myNumInputs(_idx[0]).input_checkvertexattribs);
1643  int _parmidx[2-1];
1644  _parmidx[1-1] = _idx[1-1] + 1;
1645 
1646  bool result;
1647  OP_Utils::evalOpParmInst(result, thissop, "input_checkvertexattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1648  return (result);
1649  }
1650  UT_StringHolder opNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1651  { return opinstNumInputs_input_vertexattribs(cookparms, &_idx); }
1652  UT_StringHolder opinstNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1653  {
1654  SOP_Node *thissop = cookparms.getNode();
1655  if (!thissop) return (myNumInputs(_idx[0]).input_vertexattribs);
1656  int _parmidx[2-1];
1657  _parmidx[1-1] = _idx[1-1] + 1;
1658 
1659  UT_StringHolder result;
1660  OP_Utils::evalOpParmInst(result, thissop, "input_vertexattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1661  return (result);
1662  }
1663  bool opNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1664  { return opinstNumInputs_input_checkprimitiveattribs(cookparms, &_idx); }
1665  bool opinstNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1666  {
1667  SOP_Node *thissop = cookparms.getNode();
1668  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitiveattribs);
1669  int _parmidx[2-1];
1670  _parmidx[1-1] = _idx[1-1] + 1;
1671 
1672  bool result;
1673  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitiveattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1674  return (result);
1675  }
1676  UT_StringHolder opNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1677  { return opinstNumInputs_input_primitiveattribs(cookparms, &_idx); }
1678  UT_StringHolder opinstNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1679  {
1680  SOP_Node *thissop = cookparms.getNode();
1681  if (!thissop) return (myNumInputs(_idx[0]).input_primitiveattribs);
1682  int _parmidx[2-1];
1683  _parmidx[1-1] = _idx[1-1] + 1;
1684 
1685  UT_StringHolder result;
1686  OP_Utils::evalOpParmInst(result, thissop, "input_primitiveattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1687  return (result);
1688  }
1689  bool opNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1690  { return opinstNumInputs_input_checkdetailattribs(cookparms, &_idx); }
1691  bool opinstNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1692  {
1693  SOP_Node *thissop = cookparms.getNode();
1694  if (!thissop) return (myNumInputs(_idx[0]).input_checkdetailattribs);
1695  int _parmidx[2-1];
1696  _parmidx[1-1] = _idx[1-1] + 1;
1697 
1698  bool result;
1699  OP_Utils::evalOpParmInst(result, thissop, "input_checkdetailattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1700  return (result);
1701  }
1702  UT_StringHolder opNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1703  { return opinstNumInputs_input_detailattribs(cookparms, &_idx); }
1704  UT_StringHolder opinstNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1705  {
1706  SOP_Node *thissop = cookparms.getNode();
1707  if (!thissop) return (myNumInputs(_idx[0]).input_detailattribs);
1708  int _parmidx[2-1];
1709  _parmidx[1-1] = _idx[1-1] + 1;
1710 
1711  UT_StringHolder result;
1712  OP_Utils::evalOpParmInst(result, thissop, "input_detailattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1713  return (result);
1714  }
1715  bool opNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1716  { return opinstNumInputs_input_checkpointgroups(cookparms, &_idx); }
1717  bool opinstNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1718  {
1719  SOP_Node *thissop = cookparms.getNode();
1720  if (!thissop) return (myNumInputs(_idx[0]).input_checkpointgroups);
1721  int _parmidx[2-1];
1722  _parmidx[1-1] = _idx[1-1] + 1;
1723 
1724  bool result;
1725  OP_Utils::evalOpParmInst(result, thissop, "input_checkpointgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1726  return (result);
1727  }
1728  UT_StringHolder opNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1729  { return opinstNumInputs_input_pointgroups(cookparms, &_idx); }
1730  UT_StringHolder opinstNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1731  {
1732  SOP_Node *thissop = cookparms.getNode();
1733  if (!thissop) return (myNumInputs(_idx[0]).input_pointgroups);
1734  int _parmidx[2-1];
1735  _parmidx[1-1] = _idx[1-1] + 1;
1736 
1737  UT_StringHolder result;
1738  OP_Utils::evalOpParmInst(result, thissop, "input_pointgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1739  return (result);
1740  }
1741  bool opNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1742  { return opinstNumInputs_input_checkvertexgroups(cookparms, &_idx); }
1743  bool opinstNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1744  {
1745  SOP_Node *thissop = cookparms.getNode();
1746  if (!thissop) return (myNumInputs(_idx[0]).input_checkvertexgroups);
1747  int _parmidx[2-1];
1748  _parmidx[1-1] = _idx[1-1] + 1;
1749 
1750  bool result;
1751  OP_Utils::evalOpParmInst(result, thissop, "input_checkvertexgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1752  return (result);
1753  }
1754  UT_StringHolder opNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1755  { return opinstNumInputs_input_vertexgroups(cookparms, &_idx); }
1756  UT_StringHolder opinstNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1757  {
1758  SOP_Node *thissop = cookparms.getNode();
1759  if (!thissop) return (myNumInputs(_idx[0]).input_vertexgroups);
1760  int _parmidx[2-1];
1761  _parmidx[1-1] = _idx[1-1] + 1;
1762 
1763  UT_StringHolder result;
1764  OP_Utils::evalOpParmInst(result, thissop, "input_vertexgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1765  return (result);
1766  }
1767  bool opNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1768  { return opinstNumInputs_input_checkprimitivegroups(cookparms, &_idx); }
1769  bool opinstNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1770  {
1771  SOP_Node *thissop = cookparms.getNode();
1772  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitivegroups);
1773  int _parmidx[2-1];
1774  _parmidx[1-1] = _idx[1-1] + 1;
1775 
1776  bool result;
1777  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitivegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1778  return (result);
1779  }
1780  UT_StringHolder opNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1781  { return opinstNumInputs_input_primitivegroups(cookparms, &_idx); }
1782  UT_StringHolder opinstNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1783  {
1784  SOP_Node *thissop = cookparms.getNode();
1785  if (!thissop) return (myNumInputs(_idx[0]).input_primitivegroups);
1786  int _parmidx[2-1];
1787  _parmidx[1-1] = _idx[1-1] + 1;
1788 
1789  UT_StringHolder result;
1790  OP_Utils::evalOpParmInst(result, thissop, "input_primitivegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1791  return (result);
1792  }
1793  bool opNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1794  { return opinstNumInputs_input_checkedgegroups(cookparms, &_idx); }
1795  bool opinstNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1796  {
1797  SOP_Node *thissop = cookparms.getNode();
1798  if (!thissop) return (myNumInputs(_idx[0]).input_checkedgegroups);
1799  int _parmidx[2-1];
1800  _parmidx[1-1] = _idx[1-1] + 1;
1801 
1802  bool result;
1803  OP_Utils::evalOpParmInst(result, thissop, "input_checkedgegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1804  return (result);
1805  }
1806  UT_StringHolder opNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1807  { return opinstNumInputs_input_edgegroups(cookparms, &_idx); }
1808  UT_StringHolder opinstNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1809  {
1810  SOP_Node *thissop = cookparms.getNode();
1811  if (!thissop) return (myNumInputs(_idx[0]).input_edgegroups);
1812  int _parmidx[2-1];
1813  _parmidx[1-1] = _idx[1-1] + 1;
1814 
1815  UT_StringHolder result;
1816  OP_Utils::evalOpParmInst(result, thissop, "input_edgegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1817  return (result);
1818  }
1819  bool opNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1820  { return opinstNumInputs_input_checkdetailid(cookparms, &_idx); }
1821  bool opinstNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1822  {
1823  SOP_Node *thissop = cookparms.getNode();
1824  if (!thissop) return (myNumInputs(_idx[0]).input_checkdetailid);
1825  int _parmidx[2-1];
1826  _parmidx[1-1] = _idx[1-1] + 1;
1827 
1828  bool result;
1829  OP_Utils::evalOpParmInst(result, thissop, "input_checkdetailid#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1830  return (result);
1831  }
1832  bool opNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1833  { return opinstNumInputs_input_checkprimitivesid(cookparms, &_idx); }
1834  bool opinstNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1835  {
1836  SOP_Node *thissop = cookparms.getNode();
1837  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitivesid);
1838  int _parmidx[2-1];
1839  _parmidx[1-1] = _idx[1-1] + 1;
1840 
1841  bool result;
1842  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitivesid#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1843  return (result);
1844  }
1845  bool opNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1846  { return opinstNumInputs_input_checktopology(cookparms, &_idx); }
1847  bool opinstNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1848  {
1849  SOP_Node *thissop = cookparms.getNode();
1850  if (!thissop) return (myNumInputs(_idx[0]).input_checktopology);
1851  int _parmidx[2-1];
1852  _parmidx[1-1] = _idx[1-1] + 1;
1853 
1854  bool result;
1855  OP_Utils::evalOpParmInst(result, thissop, "input_checktopology#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1856  return (result);
1857  }
1858  bool opNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1859  { return opinstNumInputs_input_checkchangecount(cookparms, &_idx); }
1860  bool opinstNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1861  {
1862  SOP_Node *thissop = cookparms.getNode();
1863  if (!thissop) return (myNumInputs(_idx[0]).input_checkchangecount);
1864  int _parmidx[2-1];
1865  _parmidx[1-1] = _idx[1-1] + 1;
1866 
1867  bool result;
1868  OP_Utils::evalOpParmInst(result, thissop, "input_checkchangecount#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1869  return (result);
1870  }
1871 
1872  CheckGroups getCheckGroups() const { return CheckGroups(myCheckGroups); }
1873  void setCheckGroups(CheckGroups val) { myCheckGroups = int64(val); }
1874  CheckGroups opCheckGroups(const SOP_NodeVerb::CookParms &cookparms) const
1875  {
1876  SOP_Node *thissop = cookparms.getNode();
1877  if (!thissop) return getCheckGroups();
1878  int64 result;
1879  OP_Utils::evalOpParm(result, thissop, "checkgroups", cookparms.getCookTime(), 0);
1880  return CheckGroups(result);
1881  }
1882  const UT_Array<NumPatterns> &getNumPatterns() const { return myNumPatterns; }
1883 void setNumPatterns(const UT_Array<NumPatterns> &val) { myNumPatterns = val; }
1884  exint opNumPatterns(const SOP_NodeVerb::CookParms &cookparms) const
1885  {
1886  SOP_Node *thissop = cookparms.getNode();
1887  if (!thissop) return getNumPatterns().entries();
1888  exint result;
1889  OP_Utils::evalOpParm(result, thissop, "numpatterns", cookparms.getCookTime(), 0);
1890  return result;
1891  }
1892  bool opNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1893  { return opinstNumPatterns_parm_enable(cookparms, &_idx); }
1894  bool opinstNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1895  {
1896  SOP_Node *thissop = cookparms.getNode();
1897  if (!thissop) return (myNumPatterns(_idx[0]).parm_enable);
1898  int _parmidx[2-1];
1899  _parmidx[1-1] = _idx[1-1] + 1;
1900 
1901  bool result;
1902  OP_Utils::evalOpParmInst(result, thissop, "parm_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1903  return (result);
1904  }
1905  UT_StringHolder opNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1906  { return opinstNumPatterns_parm_nodepath(cookparms, &_idx); }
1907  UT_StringHolder opinstNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1908  {
1909  SOP_Node *thissop = cookparms.getNode();
1910  if (!thissop) return (myNumPatterns(_idx[0]).parm_nodepath);
1911  int _parmidx[2-1];
1912  _parmidx[1-1] = _idx[1-1] + 1;
1913 
1914  UT_StringHolder result;
1915  OP_Utils::evalOpParmInst(result, thissop, "parm_nodepath#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1916  return (result);
1917  }
1918  UT_StringHolder opNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1919  { return opinstNumPatterns_parm_parmfilter(cookparms, &_idx); }
1920  UT_StringHolder opinstNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1921  {
1922  SOP_Node *thissop = cookparms.getNode();
1923  if (!thissop) return (myNumPatterns(_idx[0]).parm_parmfilter);
1924  int _parmidx[2-1];
1925  _parmidx[1-1] = _idx[1-1] + 1;
1926 
1927  UT_StringHolder result;
1928  OP_Utils::evalOpParmInst(result, thissop, "parm_parmfilter#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1929  return (result);
1930  }
1931  bool opNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1932  { return opinstNumPatterns_parm_expandmultiparms(cookparms, &_idx); }
1933  bool opinstNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1934  {
1935  SOP_Node *thissop = cookparms.getNode();
1936  if (!thissop) return (myNumPatterns(_idx[0]).parm_expandmultiparms);
1937  int _parmidx[2-1];
1938  _parmidx[1-1] = _idx[1-1] + 1;
1939 
1940  bool result;
1941  OP_Utils::evalOpParmInst(result, thissop, "parm_expandmultiparms#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1942  return (result);
1943  }
1944  UT_StringHolder opNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1945  { return opinstNumPatterns_parm_groupfilter(cookparms, &_idx); }
1946  UT_StringHolder opinstNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1947  {
1948  SOP_Node *thissop = cookparms.getNode();
1949  if (!thissop) return (myNumPatterns(_idx[0]).parm_groupfilter);
1950  int _parmidx[2-1];
1951  _parmidx[1-1] = _idx[1-1] + 1;
1952 
1953  UT_StringHolder result;
1954  OP_Utils::evalOpParmInst(result, thissop, "parm_groupfilter#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1955  return (result);
1956  }
1957  int64 opNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1958  { return opinstNumPatterns_parm_grouptype(cookparms, &_idx); }
1959  int64 opinstNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1960  {
1961  SOP_Node *thissop = cookparms.getNode();
1962  if (!thissop) return (myNumPatterns(_idx[0]).parm_grouptype);
1963  int _parmidx[2-1];
1964  _parmidx[1-1] = _idx[1-1] + 1;
1965 
1966  int64 result;
1967  OP_Utils::evalOpParmInst(result, thissop, "parm_grouptype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1968  return (result);
1969  }
1970  int64 opNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1971  { return opinstNumPatterns_parm_oninput(cookparms, &_idx); }
1972  int64 opinstNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1973  {
1974  SOP_Node *thissop = cookparms.getNode();
1975  if (!thissop) return (myNumPatterns(_idx[0]).parm_oninput);
1976  int _parmidx[2-1];
1977  _parmidx[1-1] = _idx[1-1] + 1;
1978 
1979  int64 result;
1980  OP_Utils::evalOpParmInst(result, thissop, "parm_oninput#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1981  return (result);
1982  }
1983 
1984  const UT_Array<NumExpressions> &getNumExpressions() const { return myNumExpressions; }
1985 void setNumExpressions(const UT_Array<NumExpressions> &val) { myNumExpressions = val; }
1986  exint opNumExpressions(const SOP_NodeVerb::CookParms &cookparms) const
1987  {
1988  SOP_Node *thissop = cookparms.getNode();
1989  if (!thissop) return getNumExpressions().entries();
1990  exint result;
1991  OP_Utils::evalOpParm(result, thissop, "numexpressions", cookparms.getCookTime(), 0);
1992  return result;
1993  }
1994  bool opNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1995  { return opinstNumExpressions_expr_enable(cookparms, &_idx); }
1996  bool opinstNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1997  {
1998  SOP_Node *thissop = cookparms.getNode();
1999  if (!thissop) return (myNumExpressions(_idx[0]).expr_enable);
2000  int _parmidx[2-1];
2001  _parmidx[1-1] = _idx[1-1] + 1;
2002 
2003  bool result;
2004  OP_Utils::evalOpParmInst(result, thissop, "expr_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2005  return (result);
2006  }
2007  int64 opNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2008  { return opinstNumExpressions_expr_cachewhen(cookparms, &_idx); }
2009  int64 opinstNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2010  {
2011  SOP_Node *thissop = cookparms.getNode();
2012  if (!thissop) return (myNumExpressions(_idx[0]).expr_cachewhen);
2013  int _parmidx[2-1];
2014  _parmidx[1-1] = _idx[1-1] + 1;
2015 
2016  int64 result;
2017  OP_Utils::evalOpParmInst(result, thissop, "expr_cachewhen#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2018  return (result);
2019  }
2020  int64 opNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2021  { return opinstNumExpressions_expr_exprval(cookparms, &_idx); }
2022  int64 opinstNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2023  {
2024  SOP_Node *thissop = cookparms.getNode();
2025  if (!thissop) return (myNumExpressions(_idx[0]).expr_exprval);
2026  int _parmidx[2-1];
2027  _parmidx[1-1] = _idx[1-1] + 1;
2028 
2029  int64 result;
2030  OP_Utils::evalOpParmInst(result, thissop, "expr_exprval#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2031  return (result);
2032  }
2033  int64 opNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2034  { return opinstNumExpressions_expr_exprtype(cookparms, &_idx); }
2035  int64 opinstNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2036  {
2037  SOP_Node *thissop = cookparms.getNode();
2038  if (!thissop) return (myNumExpressions(_idx[0]).expr_exprtype);
2039  int _parmidx[2-1];
2040  _parmidx[1-1] = _idx[1-1] + 1;
2041 
2042  int64 result;
2043  OP_Utils::evalOpParmInst(result, thissop, "expr_exprtype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2044  return (result);
2045  }
2046  fpreal64 opNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2047  { return opinstNumExpressions_expr_numexpr(cookparms, &_idx); }
2048  fpreal64 opinstNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2049  {
2050  SOP_Node *thissop = cookparms.getNode();
2051  if (!thissop) return (myNumExpressions(_idx[0]).expr_numexpr);
2052  int _parmidx[2-1];
2053  _parmidx[1-1] = _idx[1-1] + 1;
2054 
2055  fpreal64 result;
2056  OP_Utils::evalOpParmInst(result, thissop, "expr_numexpr#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2057  return (result);
2058  }
2059  UT_StringHolder opNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2060  { return opinstNumExpressions_expr_strexpr(cookparms, &_idx); }
2061  UT_StringHolder opinstNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2062  {
2063  SOP_Node *thissop = cookparms.getNode();
2064  if (!thissop) return (myNumExpressions(_idx[0]).expr_strexpr);
2065  int _parmidx[2-1];
2066  _parmidx[1-1] = _idx[1-1] + 1;
2067 
2068  UT_StringHolder result;
2069  OP_Utils::evalOpParmInst(result, thissop, "expr_strexpr#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2070  return (result);
2071  }
2072 
2073 
2074 private:
2075  bool myCheckUpstream;
2076  bool myOutputAttrib;
2077  bool myCheckAttrib;
2078  UT_StringHolder myAttribName;
2079  UT_Array<NumInputs> myNumInputs;
2080  int64 myCheckGroups;
2081  UT_Array<NumPatterns> myNumPatterns;
2082  UT_Array<NumExpressions> myNumExpressions;
2083 
2084 };
SOP_CacheIfParms::opinstNumPatterns_parm_oninput
int64 opinstNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1972
SOP_CacheIfParms::getCheckAttrib
bool getCheckAttrib() const
Definition: SOP_CacheIf.proto.h:1568
SOP_CacheIfParms::setNumPatterns
void setNumPatterns(const UT_Array< NumPatterns > &val)
Definition: SOP_CacheIf.proto.h:1883
SOP_CacheIfParms::NumPatterns::parm_parmfilter
UT_StringHolder parm_parmfilter
Definition: SOP_CacheIf.proto.h:248
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector2I &v)
Definition: SOP_CacheIf.proto.h:1303
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Definition: SOP_CacheIf.proto.h:1297
detail::type
type
Definition: core.h:556
SOP_CacheIfParms::setCheckGroups
void setCheckGroups(CheckGroups val)
Definition: SOP_CacheIf.proto.h:1873
SOP_CacheIfParms::NumExpressions::operator!=
bool operator!=(const NumExpressions &src) const
Definition: SOP_CacheIf.proto.h:350
UT_Matrix2T< fpreal64 >
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_StringHolder s)
Definition: SOP_CacheIf.proto.h:1364
UT_Matrix3T< fpreal64 >
SOP_CacheIfEnums::Expr_CacheWhen
Expr_CacheWhen
Definition: SOP_CacheIf.proto.h:59
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
Definition: SOP_CacheIf.proto.h:1023
SOP_CacheIfParms::setCheckUpstream
void setCheckUpstream(bool val)
Definition: SOP_CacheIf.proto.h:1549
SOP_CacheIfParms::NumPatterns
Definition: SOP_CacheIf.proto.h:244
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2540
UT_Matrix4T< fpreal64 >
SOP_CacheIfParms::opinstNumInputs_input_primitiveattribs
UT_StringHolder opinstNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1678
SOP_CacheIfParms::opinstNumInputs_input_enable
bool opinstNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1600
UT_SharedPtr.h
SOP_CacheIfParms::NumInputs::operator==
bool operator==(const NumInputs &src) const
Definition: SOP_CacheIf.proto.h:151
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, fpreal64 v)
Definition: SOP_CacheIf.proto.h:1348
SOP_CacheIfParms::getNumPatterns
const UT_Array< NumPatterns > & getNumPatterns() const
Definition: SOP_CacheIf.proto.h:1882
SOP_CacheIfParms::opNumInputs_input_checktopology
bool opNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1845
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix2D v)
Definition: SOP_CacheIf.proto.h:1358
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
Definition: SOP_CacheIf.proto.h:814
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix3D v)
Definition: SOP_CacheIf.proto.h:1360
int32
int int32
Definition: SYS_Types.h:39
SOP_NodeVerb::CookParms::getNode
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:347
SOP_CacheIfParms::NumInputs::input_enable
bool input_enable
Definition: SOP_CacheIf.proto.h:102
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Matrix4D &v)
Definition: SOP_CacheIf.proto.h:1301
UT_WorkBuffer
Definition: UT_WorkBuffer.h:74
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, PRM_DataItemHandle s)
Definition: SOP_CacheIf.proto.h:1373
SOP_CacheIfParms::opNumExpressions_expr_enable
bool opNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1994
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector3D &v)
Definition: SOP_CacheIf.proto.h:1291
SOP_CacheIfParms::opinstNumInputs_input_checktopology
bool opinstNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1847
SOP_CacheIfParms::createString
UT_StringHolder createString(const UT_Array< NumInputs > &list) const
Definition: SOP_CacheIf.proto.h:184
OP_GraphProxy
Definition: OP_GraphProxy.h:33
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, int64 &v)
Definition: SOP_CacheIf.proto.h:1283
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_StringHolder &v)
Definition: SOP_CacheIf.proto.h:1311
SOP_CacheIfEnums::Expr_ExprType
Expr_ExprType
Definition: SOP_CacheIf.proto.h:76
SOP_CacheIfParms::version
static int version()
Definition: SOP_CacheIf.proto.h:99
void
void
Definition: png.h:1083
SOP_CacheIfParms::NumExpressions::expr_exprtype
int64 expr_exprtype
Definition: SOP_CacheIf.proto.h:323
UT_IStream::bread
exint bread(int32 *buffer, exint asize=1)
data
GLboolean * data
Definition: glcorearb.h:131
SOP_CacheIfParms::setOutputAttrib
void setOutputAttrib(bool val)
Definition: SOP_CacheIf.proto.h:1559
SOP_CacheIfEnums::CheckGroups::UPSTREAM
GT_Names::time
GT_API const UT_StringHolder time
SOP_CacheIfParms::opinstNumPatterns_parm_groupfilter
UT_StringHolder opinstNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1946
UT_Vector4T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector4.h:493
v
const GLdouble * v
Definition: glcorearb.h:837
OP_Context::getTime
fpreal getTime() const
Definition: OP_Context.h:63
SOP_CacheIfParms::NumPatterns::parm_expandmultiparms
bool parm_expandmultiparms
Definition: SOP_CacheIf.proto.h:249
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector2D &v)
Definition: SOP_CacheIf.proto.h:1289
SOP_CacheIfParms::NumInputs::input_primitivegroups
UT_StringHolder input_primitivegroups
Definition: SOP_CacheIf.proto.h:116
SOP_CacheIfParms::NumPatterns::operator==
bool operator==(const NumPatterns &src) const
Definition: SOP_CacheIf.proto.h:267
SOP_CacheIfParms::opinstNumInputs_input_vertexgroups
UT_StringHolder opinstNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1756
SOP_CacheIfParms::load
bool load(UT_IStream &is)
Definition: SOP_CacheIf.proto.h:1463
value
GLsizei const GLfloat * value
Definition: glcorearb.h:824
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector4D v)
Definition: SOP_CacheIf.proto.h:1355
UT_IStream
Definition: UT_IStream.h:56
SOP_CacheIfParms::NumExpressions::expr_exprval
int64 expr_exprval
Definition: SOP_CacheIf.proto.h:322
SOP_CacheIfParms::NumInputs::operator!=
bool operator!=(const NumInputs &src) const
Definition: SOP_CacheIf.proto.h:177
SOP_CacheIfParms::opNumInputs_input_checkpointgroups
bool opNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1715
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, int64 v)
Definition: SOP_CacheIf.proto.h:1344
SOP_CacheIfParms::NumExpressions
Definition: SOP_CacheIf.proto.h:318
UT_String::makeQuotedString
UT_String makeQuotedString(char delimiter='\'', bool escape_nonprinting=false) const
SOP_CacheIfParms::setCheckAttrib
void setCheckAttrib(bool val)
Definition: SOP_CacheIf.proto.h:1569
OP_NodeParms::LoadParms::context
const OP_Context & context() const
Definition: OP_NodeParms.h:97
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
Definition: SOP_CacheIf.proto.h:1324
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
Definition: SOP_CacheIf.proto.h:820
SOP_CacheIfParms::getAttribName
const UT_StringHolder & getAttribName() const
Definition: SOP_CacheIf.proto.h:1578
UT_Vector3T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector3.h:667
exint
int64 exint
Definition: SYS_Types.h:125
SOP_CacheIfParms::NumPatterns::parm_nodepath
UT_StringHolder parm_nodepath
Definition: SOP_CacheIf.proto.h:247
UT_IStream.h
UT_WorkBuffer::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_WorkBuffer.h:169
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
Definition: SOP_CacheIf.proto.h:800
SOP_CacheIfEnums::getToken
SYS_FORCE_INLINE UT_StringHolder getToken(CheckGroups enum_value)
Definition: SOP_CacheIf.proto.h:32
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
Definition: SOP_CacheIf.proto.h:1015
SOP_CacheIfParms::NumPatterns::parm_enable
bool parm_enable
Definition: SOP_CacheIf.proto.h:246
SOP_CacheIfParms::NumInputs::input_checkprimitivesid
bool input_checkprimitivesid
Definition: SOP_CacheIf.proto.h:120
s
GLdouble s
Definition: glad.h:3009
SOP_CacheIfParms::NumPatterns::parm_oninput
int64 parm_oninput
Definition: SOP_CacheIf.proto.h:252
SOP_CacheIfParms::setAttribName
void setAttribName(const UT_StringHolder &val)
Definition: SOP_CacheIf.proto.h:1579
SOP_CacheIfParms::NumExpressions::expr_strexpr
UT_StringHolder expr_strexpr
Definition: SOP_CacheIf.proto.h:325
length
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
SOP_CacheIfParms::NumInputs::input_checkvertexgroups
bool input_checkvertexgroups
Definition: SOP_CacheIf.proto.h:113
UT_OStringStream
An output stream object that owns its own string buffer storage.
Definition: UT_StringStream.h:159
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
Definition: SOP_CacheIf.proto.h:802
SOP_CacheIfParms::NumInputs::input_detailattribs
UT_StringHolder input_detailattribs
Definition: SOP_CacheIf.proto.h:110
SOP_CacheIfParms::opNumInputs_input_checkchangecount
bool opNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1858
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, fpreal64 &v)
Definition: SOP_CacheIf.proto.h:1287
SOP_CacheIfParms::getCheckGroups
CheckGroups getCheckGroups() const
Definition: SOP_CacheIf.proto.h:1872
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
Definition: SOP_CacheIf.proto.h:812
SOP_CacheIfParms::NumInputs::input_checktopology
bool input_checktopology
Definition: SOP_CacheIf.proto.h:121
result
**But if you need a result
Definition: thread.h:622
SOP_CacheIfParms::NumPatterns::parm_groupfilter
UT_StringHolder parm_groupfilter
Definition: SOP_CacheIf.proto.h:250
SOP_CacheIfParms::opNumPatterns_parm_expandmultiparms
bool opNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1931
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
Definition: SOP_CacheIf.proto.h:1031
SOP_CacheIfEnums::CheckGroups::COOK
SOP_CacheIfParms::operator!=
bool operator!=(const SOP_CacheIfParms &src) const
Definition: SOP_CacheIf.proto.h:421
UT_Vector3T< fpreal64 >
UT_Vector4T< fpreal64 >
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
Definition: SOP_CacheIf.proto.h:806
UT_Vector2T< fpreal64 >
SOP_CacheIfParms::NumExpressions::operator==
bool operator==(const NumExpressions &src) const
Definition: SOP_CacheIf.proto.h:339
SOP_CacheIfParms::NumInputs::input_checkdetailid
bool input_checkdetailid
Definition: SOP_CacheIf.proto.h:119
OP_NodeParms::LoadParms::nodeIdx
exint nodeIdx() const
Definition: OP_NodeParms.h:95
SOP_CacheIfParms::opinstNumExpressions_expr_enable
bool opinstNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1996
SOP_CacheIfParms::opinstNumInputs_input_checkdetailattribs
bool opinstNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1691
PRM_DataFactory::parseBinary
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
SOP_CacheIfParms::opNumExpressions_expr_numexpr
fpreal64 opNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2046
UT_StringWrap
Definition: UT_String.h:1381
UT_OStringStream::str
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
Definition: UT_StringStream.h:180
UT_Array
Definition: BV_KDOPTree.h:18
SOP_API.h
SOP_CacheIfParms::NumPatterns::NumPatterns
NumPatterns()
Definition: SOP_CacheIf.proto.h:255
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, bool &v)
Definition: SOP_CacheIf.proto.h:1285
SOP_CacheIfParms::opinstNumInputs_input_checkpointgroups
bool opinstNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1717
SOP_CacheIfParms::opinstNumPatterns_parm_enable
bool opinstNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1894
SOP_CacheIfParms::opinstNumInputs_input_checkdetailid
bool opinstNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1821
SOP_CacheIfParms::opNumExpressions_expr_strexpr
UT_StringHolder opNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2059
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
Definition: SOP_CacheIf.proto.h:1021
SOP_CacheIfParms::opNumInputs_input_enable
bool opNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1598
UT_Vector4T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
OP_GraphProxy.h
SOP_CacheIfParms::setNumInputs
void setNumInputs(const UT_Array< NumInputs > &val)
Definition: SOP_CacheIf.proto.h:1589
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
Definition: SOP_CacheIf.proto.h:1033
SOP_CacheIfParms::getNestParmName
const char * getNestParmName(TempIndex fieldnum) const override
Definition: SOP_CacheIf.proto.h:1056
SOP_CacheIfParms::NumPatterns::operator!=
bool operator!=(const NumPatterns &src) const
Definition: SOP_CacheIf.proto.h:279
SOP_CacheIfParms::opinstNumExpressions_expr_numexpr
fpreal64 opinstNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2048
offsets
GLuint GLsizei const GLuint const GLintptr * offsets
Definition: glcorearb.h:2621
SOP_CacheIfParms::NumInputs
Definition: SOP_CacheIf.proto.h:100
fpreal64
double fpreal64
Definition: SYS_Types.h:201
PRM_DataItemHandle
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: APEX_Include.h:55
UT_Vector2T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector2.h:423
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
Definition: SOP_CacheIf.proto.h:1029
SOP_CacheIfParms::opNumInputs_input_checkdetailattribs
bool opNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1689
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector2D v)
Definition: SOP_CacheIf.proto.h:1350
SOP_CacheIfParms::NumInputs::input_primitiveattribs
UT_StringHolder input_primitiveattribs
Definition: SOP_CacheIf.proto.h:108
SOP_CacheIfParms::NumPatterns::parm_grouptype
int64 parm_grouptype
Definition: SOP_CacheIf.proto.h:251
SOP_CacheIfParms::opNumInputs_input_edgegroups
UT_StringHolder opNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1806
SOP_CacheIfParms::opinstNumPatterns_parm_nodepath
UT_StringHolder opinstNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1907
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
Definition: SOP_CacheIf.proto.h:804
Alembic::Util::ALEMBIC_VERSION_NS::operator==
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
SOP_CacheIfParms::opNumExpressions_expr_cachewhen
int64 opNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2007
SOP_CacheIfParms::opNumPatterns
exint opNumPatterns(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1884
UT_StringHolder
Definition: UT_StringHolder.h:1009
OP_NodeParms::TempIndex
Definition: OP_NodeParms.h:237
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
Definition: SOP_CacheIf.proto.h:1027
SYS_Types.h
SOP_CacheIfParms::SOP_CacheIfParms
SOP_CacheIfParms()
Definition: SOP_CacheIf.proto.h:388
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector3I &v)
Definition: SOP_CacheIf.proto.h:1305
SOP_CacheIfParms::opCheckUpstream
bool opCheckUpstream(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1550
SOP_CacheIfParms::opinstNumInputs_input_pointgroups
UT_StringHolder opinstNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1730
SOP_CacheIfParms::opCheckAttrib
bool opCheckAttrib(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1570
SOP_CacheIfParms::opinstNumInputs_input_primitivegroups
UT_StringHolder opinstNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1782
SOP_CacheIfParms::opinstNumExpressions_expr_exprtype
int64 opinstNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2035
SOP_CacheIfParms::opNumExpressions
exint opNumExpressions(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1986
SOP_CacheIfParms::opOutputAttrib
bool opOutputAttrib(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1560
UT_NTStreamUtil.h
SOP_CacheIfParms::opinstNumInputs_input_edgegroups
UT_StringHolder opinstNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1808
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
Definition: SOP_CacheIf.proto.h:1366
SOP_CacheIfParms::isParmColorRamp
bool isParmColorRamp(exint idx) const override
Definition: SOP_CacheIf.proto.h:791
UT_StringRef::length
exint length() const
Definition: UT_StringHolder.h:759
SOP_CacheIfParms::opinstNumInputs_input_checkpointattribs
bool opinstNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1613
UT_ISTREAM_ASCII
Definition: UT_IStream.h:38
SOP_CacheIfParms::save
void save(std::ostream &os) const
Definition: SOP_CacheIf.proto.h:1387
SOP_CacheIfParms::getNumExpressions
const UT_Array< NumExpressions > & getNumExpressions() const
Definition: SOP_CacheIf.proto.h:1984
SOP_CacheIfParms::opNumInputs_input_detailattribs
UT_StringHolder opNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1702
UT_StringRef::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_StringHolder.h:580
UT_SharedPtr
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:36
SOP_CacheIfEnums::Parm_GroupType::POINTS
UT_Vector4T::z
constexpr SYS_FORCE_INLINE T & z() noexcept
Definition: UT_Vector4.h:495
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector4I &v)
Definition: SOP_CacheIf.proto.h:1308
SOP_CacheIfEnums::CheckGroups
CheckGroups
Definition: SOP_CacheIf.proto.h:25
SOP_CacheIfParms::NumInputs::input_checkvertexattribs
bool input_checkvertexattribs
Definition: SOP_CacheIf.proto.h:105
SOP_CacheIfParms::NumInputs::input_checkprimitivegroups
bool input_checkprimitivegroups
Definition: SOP_CacheIf.proto.h:115
SOP_CacheIfParms::NumInputs::input_checkchangecount
bool input_checkchangecount
Definition: SOP_CacheIf.proto.h:122
SOP_CacheIfParms::opNumInputs_input_checkdetailid
bool opNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1819
SOP_CacheIfParms::copyFrom
void copyFrom(const OP_NodeParms *src) override
Definition: SOP_CacheIf.proto.h:618
SOP_CacheIfParms::NumInputs::input_checkpointattribs
bool input_checkpointattribs
Definition: SOP_CacheIf.proto.h:103
SOP_CacheIfEnums::Parm_GroupType::PRIMS
SOP_CacheIfParms::createString
UT_StringHolder createString(const UT_Array< NumExpressions > &list) const
Definition: SOP_CacheIf.proto.h:357
SOP_CacheIfParms::NumExpressions::expr_cachewhen
int64 expr_cachewhen
Definition: SOP_CacheIf.proto.h:321
UT_IStream::read
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:276
OP_NodeParms::LoadParms::graph
const OP_GraphProxy * graph() const
Definition: OP_NodeParms.h:94
SYS_FORCE_INLINE
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
PRM_Parm.h
SOP_CacheIfParms::NumInputs::input_checkdetailattribs
bool input_checkdetailattribs
Definition: SOP_CacheIf.proto.h:109
OP_Utils.h
SOP_CacheIfParms::opinstNumPatterns_parm_expandmultiparms
bool opinstNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1933
SOP_CacheIfParms::doGetParmValue
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
Definition: SOP_CacheIf.proto.h:625
SOP_CacheIfParms::operator==
bool operator==(const SOP_CacheIfParms &src) const
Definition: SOP_CacheIf.proto.h:405
OP_NodeParms::ParmType
ParmType
Definition: OP_NodeParms.h:163
SOP_CacheIfParms::loadFromOpSubclass
void loadFromOpSubclass(const LoadParms &loadparms) override
Definition: SOP_CacheIf.proto.h:612
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
Definition: SOP_CacheIf.proto.h:816
SOP_CacheIfParms::opNumInputs
exint opNumInputs(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1590
UT_StringStream.h
SOP_CacheIfParms::NumExpressions::NumExpressions
NumExpressions()
Definition: SOP_CacheIf.proto.h:328
OP_GraphProxy::evalOpParmInst
virtual void evalOpParmInst(int64 &v, NodeIdx node, const char *parmname, const int *inst, const int *offsets, fpreal time, DEP_MicroNode *depnode, int nestlevel=1) const =0
int64
long long int64
Definition: SYS_Types.h:116
UT_VectorTypes.h
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
Definition: SOP_CacheIf.proto.h:1313
SOP_CacheIfEnums::Expr_ExprType::FLT
SOP_CacheIfParms::opinstNumExpressions_expr_cachewhen
int64 opinstNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2009
SOP_CacheIfEnums::Expr_CacheWhen::VALUE
SOP_CacheIfParms::NumInputs::input_pointattribs
UT_StringHolder input_pointattribs
Definition: SOP_CacheIf.proto.h:104
SOP_CacheIfParms::getNestParmType
ParmType getNestParmType(TempIndex fieldnum) const override
Definition: SOP_CacheIf.proto.h:1169
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
Definition: SOP_CacheIf.proto.h:1035
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
Definition: SOP_CacheIf.proto.h:1019
SOP_CacheIfParms::NumInputs::input_checkedgegroups
bool input_checkedgegroups
Definition: SOP_CacheIf.proto.h:117
SOP_CacheIfParms::NumInputs::input_edgegroups
UT_StringHolder input_edgegroups
Definition: SOP_CacheIf.proto.h:118
OP_GraphProxy::evalOpParm
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
SOP_CacheIfParms::opinstNumPatterns_parm_parmfilter
UT_StringHolder opinstNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1920
UT_EnvControl.h
SOP_CacheIfParms::opNumPatterns_parm_enable
bool opNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1892
SOP_CacheIfParms::NumInputs::NumInputs
NumInputs()
Definition: SOP_CacheIf.proto.h:125
SOP_CacheIfParms::buildFromOp
void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
Definition: SOP_CacheIf.proto.h:432
UT_WorkBuffer::strcat
SYS_FORCE_INLINE void strcat(const char *src)
Definition: UT_WorkBuffer.h:439
UT_String::saveBinary
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:303
GT_Names::version
GT_API const UT_StringHolder version
SOP_CacheIfParms::opNumInputs_input_primitiveattribs
UT_StringHolder opNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1676
UT_Array::entries
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:655
SOP_CacheIfParms::NumInputs::input_vertexattribs
UT_StringHolder input_vertexattribs
Definition: SOP_CacheIf.proto.h:106
SOP_CacheIfParms::doSetParmValue
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
Definition: SOP_CacheIf.proto.h:825
SOP_CacheIfEnums::Parm_GroupType
Parm_GroupType
Definition: SOP_CacheIf.proto.h:42
SOP_CacheIfParms::opNumInputs_input_checkvertexattribs
bool opNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1637
SOP_CacheIfParms::setNumExpressions
void setNumExpressions(const UT_Array< NumExpressions > &val)
Definition: SOP_CacheIf.proto.h:1985
SOP_CacheIfParms::NumInputs::input_checkprimitiveattribs
bool input_checkprimitiveattribs
Definition: SOP_CacheIf.proto.h:107
SOP_CacheIfParms::opNumInputs_input_pointattribs
UT_StringHolder opNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1624
UT_WorkBuffer::appendSprintf
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
SOP_CacheIfParms::opinstNumPatterns_parm_grouptype
int64 opinstNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1959
SOP_CacheIfParms::opinstNumInputs_input_checkprimitivesid
bool opinstNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1834
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector3D v)
Definition: SOP_CacheIf.proto.h:1352
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector4D &v)
Definition: SOP_CacheIf.proto.h:1294
SOP_NodeVerb.h
SOP_CacheIfParms::NumExpressions::expr_enable
bool expr_enable
Definition: SOP_CacheIf.proto.h:320
SOP_CacheIfParms::opNumInputs_input_primitivegroups
UT_StringHolder opNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1780
UT_StringHolder.h
SOP_CacheIfParms::NumInputs::input_checkpointgroups
bool input_checkpointgroups
Definition: SOP_CacheIf.proto.h:111
SOP_CacheIfParms::opNumInputs_input_checkedgegroups
bool opNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1793
fpreal
fpreal64 fpreal
Definition: SYS_Types.h:278
OP_NodeParms::LoadParms::depnode
DEP_MicroNode * depnode() const
Definition: OP_NodeParms.h:99
SOP_CacheIfParms::opAttribName
UT_StringHolder opAttribName(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1580
SOP_CacheIfParms::getOutputAttrib
bool getOutputAttrib() const
Definition: SOP_CacheIf.proto.h:1558
SOP_CacheIfParms::opinstNumInputs_input_checkchangecount
bool opinstNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1860
nanovdb::operator=
LeafData & operator=(const LeafData &)=delete
SOP_CacheIfParms::opinstNumInputs_input_vertexattribs
UT_StringHolder opinstNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1652
UT_Ramp
Utility class for containing a color ramp.
Definition: UT_Ramp.h:96
UT_Vector4T::w
constexpr SYS_FORCE_INLINE T & w() noexcept
Definition: UT_Vector4.h:497
UT_WorkBuffer::append
SYS_FORCE_INLINE void append(char character)
Definition: UT_WorkBuffer.h:623
SOP_NodeParms
Definition: SOP_NodeVerb.h:58
SOP_CacheIfParms::NumInputs::input_pointgroups
UT_StringHolder input_pointgroups
Definition: SOP_CacheIf.proto.h:112
val
GLuint GLfloat * val
Definition: glcorearb.h:1608
SOP_CacheIfParms
Definition: SOP_CacheIf.proto.h:96
OP_NodeParms::baseGetSignature
virtual UT_StringHolder baseGetSignature() const
Definition: OP_NodeParms.h:294
OP_NodeParms::LoadParms
Definition: OP_NodeParms.h:72
UT_ISTREAM_BINARY
Definition: UT_IStream.h:39
SOP_CacheIfParms::createString
UT_StringHolder createString(const UT_Array< NumPatterns > &list) const
Definition: SOP_CacheIf.proto.h:286
SOP_API
#define SOP_API
Definition: SOP_API.h:10
SOP_CacheIfParms::opNumInputs_input_checkprimitivegroups
bool opNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1767
SOP_CacheIfParms::getNestNumParms
exint getNestNumParms(TempIndex idx) const override
Definition: SOP_CacheIf.proto.h:1038
SOP_CacheIfParms::opinstNumInputs_input_checkvertexgroups
bool opinstNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1743
OP_NodeParms
Definition: OP_NodeParms.h:66
SOP_CacheIfParms::opinstNumInputs_input_checkedgegroups
bool opinstNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1795
SOP_NodeVerb::CookParms::getCookTime
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:372
SOP_CacheIfParms::opNumInputs_input_pointgroups
UT_StringHolder opNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1728
UT_String
Definition: UT_String.h:73
SOP_CacheIfParms::opNumInputs_input_vertexattribs
UT_StringHolder opNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1650
SOP_CacheIfEnums::Expr_CacheWhen::CHANGE
SOP_CacheIfParms::opNumPatterns_parm_parmfilter
UT_StringHolder opNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1918
SOP_NodeVerb::CookParms
Definition: SOP_NodeVerb.h:310
UT_StringWrap::findChar
const char * findChar(int c) const
Definition: UT_String.h:1401
UT_ASSERT
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
SOP_CacheIfParms::opNumPatterns_parm_nodepath
UT_StringHolder opNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1905
SOP_CacheIfParms::opinstNumInputs_input_checkprimitiveattribs
bool opinstNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1665
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
Definition: SOP_CacheIf.proto.h:810
SOP_CacheIfParms::opNumPatterns_parm_groupfilter
UT_StringHolder opNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1944
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
Definition: SOP_CacheIf.proto.h:808
SOP_CacheIfParms::NumExpressions::expr_numexpr
fpreal64 expr_numexpr
Definition: SOP_CacheIf.proto.h:324
r
GLboolean r
Definition: glcorearb.h:1222
DEP_MicroNode
Definition: DEP_MicroNode.h:60
SOP_CacheIfEnums::Expr_ExprType::STR
SOP_CacheIfParms::opNumPatterns_parm_grouptype
int64 opNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1957
SOP_CacheIfParms::opNumInputs_input_checkpointattribs
bool opNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1611
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
Definition: SOP_CacheIf.proto.h:1017
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, bool v)
Definition: SOP_CacheIf.proto.h:1346
UT_Vector3T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector3.h:665
SOP_CacheIfParms::getNumInputs
const UT_Array< NumInputs > & getNumInputs() const
Definition: SOP_CacheIf.proto.h:1588
OP_NodeParms::TempIndex::size
exint size() const
Definition: OP_NodeParms.h:255
SOP_CacheIfParms::opinstNumInputs_input_checkvertexattribs
bool opinstNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1639
OP_GraphProxy::isDirect
virtual bool isDirect() const =0
Direct proxies mirror actual nodes:
SOP_CacheIfParms::opNumInputs_input_checkprimitivesid
bool opNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1832
SOP_CacheIfParms::opNumExpressions_expr_exprtype
int64 opNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2033
SOP_CacheIfParms::opNumInputs_input_checkvertexgroups
bool opNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1741
SOP_CacheIfParms::opinstNumInputs_input_checkprimitivegroups
bool opinstNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1769
SOP_CacheIfParms::opCheckGroups
CheckGroups opCheckGroups(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1874
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
Definition: SOP_CacheIf.proto.h:1025
UT_Vector2T::y
constexpr SYS_FORCE_INLINE T & y() noexcept
Definition: UT_Vector2.h:425
SOP_CacheIfParms::opinstNumExpressions_expr_strexpr
UT_StringHolder opinstNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2061
UT_StringRef::isstring
SYS_FORCE_INLINE bool isstring() const
Definition: UT_StringHolder.h:617
SOP_CacheIfParms::getCheckUpstream
bool getCheckUpstream() const
Definition: SOP_CacheIf.proto.h:1548
SOP_CacheIfParms::opinstNumInputs_input_detailattribs
UT_StringHolder opinstNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1704
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix4D v)
Definition: SOP_CacheIf.proto.h:1362
SOP_Node
Definition: SOP_Node.h:111
SOP_CacheIfParms::opinstNumInputs_input_pointattribs
UT_StringHolder opinstNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1626
UT_WorkBuffer::strncpy
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
Definition: UT_WorkBuffer.h:413
SOP_CacheIfParms::NumInputs::input_vertexgroups
UT_StringHolder input_vertexgroups
Definition: SOP_CacheIf.proto.h:114
SOP_CacheIfParms::opNumInputs_input_checkprimitiveattribs
bool opNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1663
SOP_CacheIfParms::opinstNumExpressions_expr_exprval
int64 opinstNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2022
SOP_CacheIfParms::opNumExpressions_expr_exprval
int64 opNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2020
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Matrix3D &v)
Definition: SOP_CacheIf.proto.h:1299
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
Definition: SOP_CacheIf.proto.h:818
SOP_CacheIfParms::opNumInputs_input_vertexgroups
UT_StringHolder opNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1754
src
GLenum src
Definition: glcorearb.h:1793
UT_Vector3T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector3.h:663
SOP_CacheIfParms::opNumPatterns_parm_oninput
int64 opNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1970
UT_Ramp.h