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 <SOP/SOP_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  return true;
417  }
418  bool operator!=(const SOP_CacheIfParms &src) const
419  {
420  return !operator==(src);
421  }
422  using CheckGroups = SOP_CacheIfEnums::CheckGroups;
423  using Parm_GroupType = SOP_CacheIfEnums::Parm_GroupType;
424  using Expr_CacheWhen = SOP_CacheIfEnums::Expr_CacheWhen;
425  using Expr_ExprType = SOP_CacheIfEnums::Expr_ExprType;
426 
427 
428 
429  void buildFromOp(const OP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
430  {
431  myCheckUpstream = false;
432  if (true)
433  graph->evalOpParm(myCheckUpstream, nodeidx, "checkupstream", time, 0);
434  myOutputAttrib = false;
435  if (true)
436  graph->evalOpParm(myOutputAttrib, nodeidx, "outputattrib", time, 0);
437  myCheckAttrib = false;
438  if (true)
439  graph->evalOpParm(myCheckAttrib, nodeidx, "checkattrib", time, 0);
440  myAttribName = ""_UTsh;
441  if (true)
442  graph->evalOpParm(myAttribName, nodeidx, "attribname", time, 0);
443  if (true)
444  {
445  int64 length = 0;
446  graph->evalOpParm(length, nodeidx, "numinputs", time, 0);
447  if (length < 0) length = 0;
448  myNumInputs.setSize(length);
449  for (exint i = 0; i < length; i++)
450  {
451  int parmidx[1];
452  int offsets[1];
453  parmidx[0] = i+1;
454  offsets[0] = 1;
455  auto && _curentry = myNumInputs(i);
456  (void) _curentry;
457  _curentry.input_enable = true;
458  if (true)
459  graph->evalOpParmInst(_curentry.input_enable, nodeidx, "input_enable#", parmidx, offsets, time, 0, 2-1);
460  _curentry.input_checkpointattribs = false;
461  if (true)
462  graph->evalOpParmInst(_curentry.input_checkpointattribs, nodeidx, "input_checkpointattribs#", parmidx, offsets, time, 0, 2-1);
463  _curentry.input_pointattribs = ""_UTsh;
464  if (true && ( (true&&!(((_curentry.input_checkpointattribs==0)))) ) )
465  graph->evalOpParmInst(_curentry.input_pointattribs, nodeidx, "input_pointattribs#", parmidx, offsets, time, 0, 2-1);
466  _curentry.input_checkvertexattribs = false;
467  if (true)
468  graph->evalOpParmInst(_curentry.input_checkvertexattribs, nodeidx, "input_checkvertexattribs#", parmidx, offsets, time, 0, 2-1);
469  _curentry.input_vertexattribs = ""_UTsh;
470  if (true && ( (true&&!(((_curentry.input_checkvertexattribs==0)))) ) )
471  graph->evalOpParmInst(_curentry.input_vertexattribs, nodeidx, "input_vertexattribs#", parmidx, offsets, time, 0, 2-1);
472  _curentry.input_checkprimitiveattribs = false;
473  if (true)
474  graph->evalOpParmInst(_curentry.input_checkprimitiveattribs, nodeidx, "input_checkprimitiveattribs#", parmidx, offsets, time, 0, 2-1);
475  _curentry.input_primitiveattribs = ""_UTsh;
476  if (true && ( (true&&!(((_curentry.input_checkprimitiveattribs==0)))) ) )
477  graph->evalOpParmInst(_curentry.input_primitiveattribs, nodeidx, "input_primitiveattribs#", parmidx, offsets, time, 0, 2-1);
478  _curentry.input_checkdetailattribs = false;
479  if (true)
480  graph->evalOpParmInst(_curentry.input_checkdetailattribs, nodeidx, "input_checkdetailattribs#", parmidx, offsets, time, 0, 2-1);
481  _curentry.input_detailattribs = ""_UTsh;
482  if (true && ( (true&&!(((_curentry.input_checkdetailattribs==0)))) ) )
483  graph->evalOpParmInst(_curentry.input_detailattribs, nodeidx, "input_detailattribs#", parmidx, offsets, time, 0, 2-1);
484  _curentry.input_checkpointgroups = false;
485  if (true)
486  graph->evalOpParmInst(_curentry.input_checkpointgroups, nodeidx, "input_checkpointgroups#", parmidx, offsets, time, 0, 2-1);
487  _curentry.input_pointgroups = ""_UTsh;
488  if (true && ( (true&&!(((_curentry.input_checkpointgroups==0)))) ) )
489  graph->evalOpParmInst(_curentry.input_pointgroups, nodeidx, "input_pointgroups#", parmidx, offsets, time, 0, 2-1);
490  _curentry.input_checkvertexgroups = false;
491  if (true)
492  graph->evalOpParmInst(_curentry.input_checkvertexgroups, nodeidx, "input_checkvertexgroups#", parmidx, offsets, time, 0, 2-1);
493  _curentry.input_vertexgroups = ""_UTsh;
494  if (true && ( (true&&!(((_curentry.input_checkvertexgroups==0)))) ) )
495  graph->evalOpParmInst(_curentry.input_vertexgroups, nodeidx, "input_vertexgroups#", parmidx, offsets, time, 0, 2-1);
496  _curentry.input_checkprimitivegroups = false;
497  if (true)
498  graph->evalOpParmInst(_curentry.input_checkprimitivegroups, nodeidx, "input_checkprimitivegroups#", parmidx, offsets, time, 0, 2-1);
499  _curentry.input_primitivegroups = ""_UTsh;
500  if (true && ( (true&&!(((_curentry.input_checkprimitivegroups==0)))) ) )
501  graph->evalOpParmInst(_curentry.input_primitivegroups, nodeidx, "input_primitivegroups#", parmidx, offsets, time, 0, 2-1);
502  _curentry.input_checkedgegroups = false;
503  if (true)
504  graph->evalOpParmInst(_curentry.input_checkedgegroups, nodeidx, "input_checkedgegroups#", parmidx, offsets, time, 0, 2-1);
505  _curentry.input_edgegroups = ""_UTsh;
506  if (true && ( (true&&!(((_curentry.input_checkedgegroups==0)))) ) )
507  graph->evalOpParmInst(_curentry.input_edgegroups, nodeidx, "input_edgegroups#", parmidx, offsets, time, 0, 2-1);
508  _curentry.input_checkdetailid = false;
509  if (true)
510  graph->evalOpParmInst(_curentry.input_checkdetailid, nodeidx, "input_checkdetailid#", parmidx, offsets, time, 0, 2-1);
511  _curentry.input_checkprimitivesid = true;
512  if (true)
513  graph->evalOpParmInst(_curentry.input_checkprimitivesid, nodeidx, "input_checkprimitivesid#", parmidx, offsets, time, 0, 2-1);
514  _curentry.input_checktopology = true;
515  if (true)
516  graph->evalOpParmInst(_curentry.input_checktopology, nodeidx, "input_checktopology#", parmidx, offsets, time, 0, 2-1);
517  _curentry.input_checkchangecount = false;
518  if (true)
519  graph->evalOpParmInst(_curentry.input_checkchangecount, nodeidx, "input_checkchangecount#", parmidx, offsets, time, 0, 2-1);
520 
521  }
522  }
523  else
524  myNumInputs.clear();
525  myCheckGroups = 1;
526  if (true)
527  graph->evalOpParm(myCheckGroups, nodeidx, "checkgroups", time, 0);
528  if (true)
529  {
530  int64 length = 0;
531  graph->evalOpParm(length, nodeidx, "numpatterns", time, 0);
532  if (length < 0) length = 0;
533  myNumPatterns.setSize(length);
534  for (exint i = 0; i < length; i++)
535  {
536  int parmidx[1];
537  int offsets[1];
538  parmidx[0] = i+1;
539  offsets[0] = 1;
540  auto && _curentry = myNumPatterns(i);
541  (void) _curentry;
542  _curentry.parm_enable = true;
543  if (true)
544  graph->evalOpParmInst(_curentry.parm_enable, nodeidx, "parm_enable#", parmidx, offsets, time, 0, 2-1);
545  _curentry.parm_nodepath = ""_UTsh;
546  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
547  graph->evalOpParmInst(_curentry.parm_nodepath, nodeidx, "parm_nodepath#", parmidx, offsets, time, 0, 2-1);
548  _curentry.parm_parmfilter = "*"_UTsh;
549  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
550  graph->evalOpParmInst(_curentry.parm_parmfilter, nodeidx, "parm_parmfilter#", parmidx, offsets, time, 0, 2-1);
551  _curentry.parm_expandmultiparms = true;
552  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
553  graph->evalOpParmInst(_curentry.parm_expandmultiparms, nodeidx, "parm_expandmultiparms#", parmidx, offsets, time, 0, 2-1);
554  _curentry.parm_groupfilter = ""_UTsh;
555  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
556  graph->evalOpParmInst(_curentry.parm_groupfilter, nodeidx, "parm_groupfilter#", parmidx, offsets, time, 0, 2-1);
557  _curentry.parm_grouptype = 1;
558  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
559  graph->evalOpParmInst(_curentry.parm_grouptype, nodeidx, "parm_grouptype#", parmidx, offsets, time, 0, 2-1);
560  _curentry.parm_oninput = 0;
561  if (true && ( (true&&!(((_curentry.parm_enable==0)))) ) )
562  graph->evalOpParmInst(_curentry.parm_oninput, nodeidx, "parm_oninput#", parmidx, offsets, time, 0, 2-1);
563 
564  }
565  }
566  else
567  myNumPatterns.clear();
568  if (true)
569  {
570  int64 length = 0;
571  graph->evalOpParm(length, nodeidx, "numexpressions", time, 0);
572  if (length < 0) length = 0;
573  myNumExpressions.setSize(length);
574  for (exint i = 0; i < length; i++)
575  {
576  int parmidx[1];
577  int offsets[1];
578  parmidx[0] = i+1;
579  offsets[0] = 1;
580  auto && _curentry = myNumExpressions(i);
581  (void) _curentry;
582  _curentry.expr_enable = true;
583  if (true)
584  graph->evalOpParmInst(_curentry.expr_enable, nodeidx, "expr_enable#", parmidx, offsets, time, 0, 2-1);
585  _curentry.expr_cachewhen = 0;
586  if (true && ( (true&&!(((_curentry.expr_enable==0)))) ) )
587  graph->evalOpParmInst(_curentry.expr_cachewhen, nodeidx, "expr_cachewhen#", parmidx, offsets, time, 0, 2-1);
588  _curentry.expr_exprval = 0;
589  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=0)))) ) )
590  graph->evalOpParmInst(_curentry.expr_exprval, nodeidx, "expr_exprval#", parmidx, offsets, time, 0, 2-1);
591  _curentry.expr_exprtype = 0;
592  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1)))) ) )
593  graph->evalOpParmInst(_curentry.expr_exprtype, nodeidx, "expr_exprtype#", parmidx, offsets, time, 0, 2-1);
594  _curentry.expr_numexpr = 0;
595  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1))||((_curentry.expr_exprtype!=0)))) ) )
596  graph->evalOpParmInst(_curentry.expr_numexpr, nodeidx, "expr_numexpr#", parmidx, offsets, time, 0, 2-1);
597  _curentry.expr_strexpr = ""_UTsh;
598  if (true && ( (true&&!(((_curentry.expr_enable==0))||((_curentry.expr_cachewhen!=1))||((_curentry.expr_exprtype!=1)))) ) )
599  graph->evalOpParmInst(_curentry.expr_strexpr, nodeidx, "expr_strexpr#", parmidx, offsets, time, 0, 2-1);
600 
601  }
602  }
603  else
604  myNumExpressions.clear();
605 
606  }
607 
608 
609  void loadFromOpSubclass(const LoadParms &loadparms) override
610  {
611  buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
612  }
613 
614 
615  void copyFrom(const OP_NodeParms *src) override
616  {
617  *this = *((const SOP_CacheIfParms *)src);
618  }
619 
620  template <typename T>
621  void
622  doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
623  {
624  if (idx.size() < 1)
625  return;
626  UT_ASSERT(idx.size() == instance.size()+1);
627  if (idx.size() != instance.size()+1)
628  return;
629  switch (idx[0])
630  {
631  case 0:
632  coerceValue(value, myCheckUpstream);
633  break;
634  case 1:
635  coerceValue(value, myOutputAttrib);
636  break;
637  case 2:
638  coerceValue(value, myCheckAttrib);
639  break;
640  case 3:
641  coerceValue(value, myAttribName);
642  break;
643  case 4:
644  if (idx.size() == 1)
645  coerceValue(value, myNumInputs.entries());
646  else if (instance[0] < myNumInputs.entries())
647  {
648  auto && _data = myNumInputs(instance[0]);
649  switch (idx[1])
650  {
651  case 0:
652  coerceValue(value, _data.input_enable);
653  break;
654  case 1:
655  coerceValue(value, _data.input_checkpointattribs);
656  break;
657  case 2:
658  coerceValue(value, _data.input_pointattribs);
659  break;
660  case 3:
661  coerceValue(value, _data.input_checkvertexattribs);
662  break;
663  case 4:
664  coerceValue(value, _data.input_vertexattribs);
665  break;
666  case 5:
667  coerceValue(value, _data.input_checkprimitiveattribs);
668  break;
669  case 6:
670  coerceValue(value, _data.input_primitiveattribs);
671  break;
672  case 7:
673  coerceValue(value, _data.input_checkdetailattribs);
674  break;
675  case 8:
676  coerceValue(value, _data.input_detailattribs);
677  break;
678  case 9:
679  coerceValue(value, _data.input_checkpointgroups);
680  break;
681  case 10:
682  coerceValue(value, _data.input_pointgroups);
683  break;
684  case 11:
685  coerceValue(value, _data.input_checkvertexgroups);
686  break;
687  case 12:
688  coerceValue(value, _data.input_vertexgroups);
689  break;
690  case 13:
691  coerceValue(value, _data.input_checkprimitivegroups);
692  break;
693  case 14:
694  coerceValue(value, _data.input_primitivegroups);
695  break;
696  case 15:
697  coerceValue(value, _data.input_checkedgegroups);
698  break;
699  case 16:
700  coerceValue(value, _data.input_edgegroups);
701  break;
702  case 17:
703  coerceValue(value, _data.input_checkdetailid);
704  break;
705  case 18:
706  coerceValue(value, _data.input_checkprimitivesid);
707  break;
708  case 19:
709  coerceValue(value, _data.input_checktopology);
710  break;
711  case 20:
712  coerceValue(value, _data.input_checkchangecount);
713  break;
714 
715  }
716  }
717  break;
718  case 5:
719  coerceValue(value, myCheckGroups);
720  break;
721  case 6:
722  if (idx.size() == 1)
723  coerceValue(value, myNumPatterns.entries());
724  else if (instance[0] < myNumPatterns.entries())
725  {
726  auto && _data = myNumPatterns(instance[0]);
727  switch (idx[1])
728  {
729  case 0:
730  coerceValue(value, _data.parm_enable);
731  break;
732  case 1:
733  coerceValue(value, _data.parm_nodepath);
734  break;
735  case 2:
736  coerceValue(value, _data.parm_parmfilter);
737  break;
738  case 3:
739  coerceValue(value, _data.parm_expandmultiparms);
740  break;
741  case 4:
742  coerceValue(value, _data.parm_groupfilter);
743  break;
744  case 5:
745  coerceValue(value, _data.parm_grouptype);
746  break;
747  case 6:
748  coerceValue(value, _data.parm_oninput);
749  break;
750 
751  }
752  }
753  break;
754  case 7:
755  if (idx.size() == 1)
756  coerceValue(value, myNumExpressions.entries());
757  else if (instance[0] < myNumExpressions.entries())
758  {
759  auto && _data = myNumExpressions(instance[0]);
760  switch (idx[1])
761  {
762  case 0:
763  coerceValue(value, _data.expr_enable);
764  break;
765  case 1:
766  coerceValue(value, _data.expr_cachewhen);
767  break;
768  case 2:
769  coerceValue(value, _data.expr_exprval);
770  break;
771  case 3:
772  coerceValue(value, _data.expr_exprtype);
773  break;
774  case 4:
775  coerceValue(value, _data.expr_numexpr);
776  break;
777  case 5:
778  coerceValue(value, _data.expr_strexpr);
779  break;
780 
781  }
782  }
783  break;
784 
785  }
786  }
787 
788  bool isParmColorRamp(exint idx) const override
789  {
790  switch (idx)
791  {
792 
793  }
794  return false;
795  }
796 
797  void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
798  { doGetParmValue(idx, instance, value); }
799  void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
800  { doGetParmValue(idx, instance, value); }
801  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
802  { doGetParmValue(idx, instance, value); }
803  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
804  { doGetParmValue(idx, instance, value); }
805  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
806  { doGetParmValue(idx, instance, value); }
807  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
808  { doGetParmValue(idx, instance, value); }
809  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
810  { doGetParmValue(idx, instance, value); }
811  void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
812  { doGetParmValue(idx, instance, value); }
813  void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
814  { doGetParmValue(idx, instance, value); }
815  void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
816  { doGetParmValue(idx, instance, value); }
817  void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
818  { doGetParmValue(idx, instance, value); }
819 
820  template <typename T>
821  void
822  doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
823  {
824  if (idx.size() < 1)
825  return;
826  UT_ASSERT(idx.size() == instance.size()+1);
827  if (idx.size() != instance.size()+1)
828  return;
829  switch (idx[0])
830  {
831  case 0:
832  coerceValue(myCheckUpstream, ( ( value ) ));
833  break;
834  case 1:
835  coerceValue(myOutputAttrib, ( ( value ) ));
836  break;
837  case 2:
838  coerceValue(myCheckAttrib, ( ( value ) ));
839  break;
840  case 3:
841  coerceValue(myAttribName, ( ( value ) ));
842  break;
843  case 4:
844  if (idx.size() == 1)
845  {
846  exint newsize;
847  coerceValue(newsize, value);
848  if (newsize < 0) newsize = 0;
849  myNumInputs.setSize(newsize);
850  }
851  else
852  {
853  if (instance[0] < 0)
854  return;
855  myNumInputs.setSizeIfNeeded(instance[0]+1);
856  auto && _data = myNumInputs(instance[0]);
857  switch (idx[1])
858  {
859  case 0:
860  coerceValue(_data.input_enable, value);
861  break;
862  case 1:
863  coerceValue(_data.input_checkpointattribs, value);
864  break;
865  case 2:
866  coerceValue(_data.input_pointattribs, value);
867  break;
868  case 3:
869  coerceValue(_data.input_checkvertexattribs, value);
870  break;
871  case 4:
872  coerceValue(_data.input_vertexattribs, value);
873  break;
874  case 5:
875  coerceValue(_data.input_checkprimitiveattribs, value);
876  break;
877  case 6:
878  coerceValue(_data.input_primitiveattribs, value);
879  break;
880  case 7:
881  coerceValue(_data.input_checkdetailattribs, value);
882  break;
883  case 8:
884  coerceValue(_data.input_detailattribs, value);
885  break;
886  case 9:
887  coerceValue(_data.input_checkpointgroups, value);
888  break;
889  case 10:
890  coerceValue(_data.input_pointgroups, value);
891  break;
892  case 11:
893  coerceValue(_data.input_checkvertexgroups, value);
894  break;
895  case 12:
896  coerceValue(_data.input_vertexgroups, value);
897  break;
898  case 13:
899  coerceValue(_data.input_checkprimitivegroups, value);
900  break;
901  case 14:
902  coerceValue(_data.input_primitivegroups, value);
903  break;
904  case 15:
905  coerceValue(_data.input_checkedgegroups, value);
906  break;
907  case 16:
908  coerceValue(_data.input_edgegroups, value);
909  break;
910  case 17:
911  coerceValue(_data.input_checkdetailid, value);
912  break;
913  case 18:
914  coerceValue(_data.input_checkprimitivesid, value);
915  break;
916  case 19:
917  coerceValue(_data.input_checktopology, value);
918  break;
919  case 20:
920  coerceValue(_data.input_checkchangecount, value);
921  break;
922 
923  }
924  }
925  break;
926  case 5:
927  coerceValue(myCheckGroups, clampMinValue(0, clampMaxValue(1, value ) ));
928  break;
929  case 6:
930  if (idx.size() == 1)
931  {
932  exint newsize;
933  coerceValue(newsize, value);
934  if (newsize < 0) newsize = 0;
935  myNumPatterns.setSize(newsize);
936  }
937  else
938  {
939  if (instance[0] < 0)
940  return;
941  myNumPatterns.setSizeIfNeeded(instance[0]+1);
942  auto && _data = myNumPatterns(instance[0]);
943  switch (idx[1])
944  {
945  case 0:
946  coerceValue(_data.parm_enable, value);
947  break;
948  case 1:
949  coerceValue(_data.parm_nodepath, value);
950  break;
951  case 2:
952  coerceValue(_data.parm_parmfilter, value);
953  break;
954  case 3:
955  coerceValue(_data.parm_expandmultiparms, value);
956  break;
957  case 4:
958  coerceValue(_data.parm_groupfilter, value);
959  break;
960  case 5:
961  coerceValue(_data.parm_grouptype, value);
962  break;
963  case 6:
964  coerceValue(_data.parm_oninput, value);
965  break;
966 
967  }
968  }
969  break;
970  case 7:
971  if (idx.size() == 1)
972  {
973  exint newsize;
974  coerceValue(newsize, value);
975  if (newsize < 0) newsize = 0;
976  myNumExpressions.setSize(newsize);
977  }
978  else
979  {
980  if (instance[0] < 0)
981  return;
982  myNumExpressions.setSizeIfNeeded(instance[0]+1);
983  auto && _data = myNumExpressions(instance[0]);
984  switch (idx[1])
985  {
986  case 0:
987  coerceValue(_data.expr_enable, value);
988  break;
989  case 1:
990  coerceValue(_data.expr_cachewhen, value);
991  break;
992  case 2:
993  coerceValue(_data.expr_exprval, value);
994  break;
995  case 3:
996  coerceValue(_data.expr_exprtype, value);
997  break;
998  case 4:
999  coerceValue(_data.expr_numexpr, value);
1000  break;
1001  case 5:
1002  coerceValue(_data.expr_strexpr, value);
1003  break;
1004 
1005  }
1006  }
1007  break;
1008 
1009  }
1010  }
1011 
1012  void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
1013  { doSetParmValue(idx, instance, value); }
1014  void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
1015  { doSetParmValue(idx, instance, value); }
1016  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
1017  { doSetParmValue(idx, instance, value); }
1018  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
1019  { doSetParmValue(idx, instance, value); }
1020  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
1021  { doSetParmValue(idx, instance, value); }
1022  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
1023  { doSetParmValue(idx, instance, value); }
1024  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
1025  { doSetParmValue(idx, instance, value); }
1026  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
1027  { doSetParmValue(idx, instance, value); }
1028  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
1029  { doSetParmValue(idx, instance, value); }
1030  void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value) override
1031  { doSetParmValue(idx, instance, value); }
1032  void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
1033  { doSetParmValue(idx, instance, value); }
1034 
1035  exint getNestNumParms(TempIndex idx) const override
1036  {
1037  if (idx.size() == 0)
1038  return 8;
1039  switch (idx[0])
1040  {
1041  case 4:
1042  return 21;
1043  case 6:
1044  return 7;
1045  case 7:
1046  return 6;
1047 
1048  }
1049  // Invalid
1050  return 0;
1051  }
1052 
1053  const char *getNestParmName(TempIndex fieldnum) const override
1054  {
1055  if (fieldnum.size() < 1)
1056  return 0;
1057  switch (fieldnum[0])
1058  {
1059  case 0:
1060  return "checkupstream";
1061  case 1:
1062  return "outputattrib";
1063  case 2:
1064  return "checkattrib";
1065  case 3:
1066  return "attribname";
1067  case 4:
1068  if (fieldnum.size() == 1)
1069  return "numinputs";
1070  switch (fieldnum[1])
1071  {
1072  case 0:
1073  return "input_enable#";
1074  case 1:
1075  return "input_checkpointattribs#";
1076  case 2:
1077  return "input_pointattribs#";
1078  case 3:
1079  return "input_checkvertexattribs#";
1080  case 4:
1081  return "input_vertexattribs#";
1082  case 5:
1083  return "input_checkprimitiveattribs#";
1084  case 6:
1085  return "input_primitiveattribs#";
1086  case 7:
1087  return "input_checkdetailattribs#";
1088  case 8:
1089  return "input_detailattribs#";
1090  case 9:
1091  return "input_checkpointgroups#";
1092  case 10:
1093  return "input_pointgroups#";
1094  case 11:
1095  return "input_checkvertexgroups#";
1096  case 12:
1097  return "input_vertexgroups#";
1098  case 13:
1099  return "input_checkprimitivegroups#";
1100  case 14:
1101  return "input_primitivegroups#";
1102  case 15:
1103  return "input_checkedgegroups#";
1104  case 16:
1105  return "input_edgegroups#";
1106  case 17:
1107  return "input_checkdetailid#";
1108  case 18:
1109  return "input_checkprimitivesid#";
1110  case 19:
1111  return "input_checktopology#";
1112  case 20:
1113  return "input_checkchangecount#";
1114 
1115  }
1116  return 0;
1117  case 5:
1118  return "checkgroups";
1119  case 6:
1120  if (fieldnum.size() == 1)
1121  return "numpatterns";
1122  switch (fieldnum[1])
1123  {
1124  case 0:
1125  return "parm_enable#";
1126  case 1:
1127  return "parm_nodepath#";
1128  case 2:
1129  return "parm_parmfilter#";
1130  case 3:
1131  return "parm_expandmultiparms#";
1132  case 4:
1133  return "parm_groupfilter#";
1134  case 5:
1135  return "parm_grouptype#";
1136  case 6:
1137  return "parm_oninput#";
1138 
1139  }
1140  return 0;
1141  case 7:
1142  if (fieldnum.size() == 1)
1143  return "numexpressions";
1144  switch (fieldnum[1])
1145  {
1146  case 0:
1147  return "expr_enable#";
1148  case 1:
1149  return "expr_cachewhen#";
1150  case 2:
1151  return "expr_exprval#";
1152  case 3:
1153  return "expr_exprtype#";
1154  case 4:
1155  return "expr_numexpr#";
1156  case 5:
1157  return "expr_strexpr#";
1158 
1159  }
1160  return 0;
1161 
1162  }
1163  return 0;
1164  }
1165 
1166  ParmType getNestParmType(TempIndex fieldnum) const override
1167  {
1168  if (fieldnum.size() < 1)
1169  return PARM_UNSUPPORTED;
1170  switch (fieldnum[0])
1171  {
1172  case 0:
1173  return PARM_INTEGER;
1174  case 1:
1175  return PARM_INTEGER;
1176  case 2:
1177  return PARM_INTEGER;
1178  case 3:
1179  return PARM_STRING;
1180  case 4:
1181  if (fieldnum.size() == 1)
1182  return PARM_MULTIPARM;
1183  switch (fieldnum[1])
1184  {
1185  case 0:
1186  return PARM_INTEGER;
1187  case 1:
1188  return PARM_INTEGER;
1189  case 2:
1190  return PARM_STRING;
1191  case 3:
1192  return PARM_INTEGER;
1193  case 4:
1194  return PARM_STRING;
1195  case 5:
1196  return PARM_INTEGER;
1197  case 6:
1198  return PARM_STRING;
1199  case 7:
1200  return PARM_INTEGER;
1201  case 8:
1202  return PARM_STRING;
1203  case 9:
1204  return PARM_INTEGER;
1205  case 10:
1206  return PARM_STRING;
1207  case 11:
1208  return PARM_INTEGER;
1209  case 12:
1210  return PARM_STRING;
1211  case 13:
1212  return PARM_INTEGER;
1213  case 14:
1214  return PARM_STRING;
1215  case 15:
1216  return PARM_INTEGER;
1217  case 16:
1218  return PARM_STRING;
1219  case 17:
1220  return PARM_INTEGER;
1221  case 18:
1222  return PARM_INTEGER;
1223  case 19:
1224  return PARM_INTEGER;
1225  case 20:
1226  return PARM_INTEGER;
1227 
1228  }
1229  return PARM_UNSUPPORTED;
1230  case 5:
1231  return PARM_INTEGER;
1232  case 6:
1233  if (fieldnum.size() == 1)
1234  return PARM_MULTIPARM;
1235  switch (fieldnum[1])
1236  {
1237  case 0:
1238  return PARM_INTEGER;
1239  case 1:
1240  return PARM_STRING;
1241  case 2:
1242  return PARM_STRING;
1243  case 3:
1244  return PARM_INTEGER;
1245  case 4:
1246  return PARM_STRING;
1247  case 5:
1248  return PARM_INTEGER;
1249  case 6:
1250  return PARM_INTEGER;
1251 
1252  }
1253  return PARM_UNSUPPORTED;
1254  case 7:
1255  if (fieldnum.size() == 1)
1256  return PARM_MULTIPARM;
1257  switch (fieldnum[1])
1258  {
1259  case 0:
1260  return PARM_INTEGER;
1261  case 1:
1262  return PARM_INTEGER;
1263  case 2:
1264  return PARM_INTEGER;
1265  case 3:
1266  return PARM_INTEGER;
1267  case 4:
1268  return PARM_FLOAT;
1269  case 5:
1270  return PARM_STRING;
1271 
1272  }
1273  return PARM_UNSUPPORTED;
1274 
1275  }
1276  return PARM_UNSUPPORTED;
1277  }
1278 
1279  // Boiler plate to load individual types.
1280  static void loadData(UT_IStream &is, int64 &v)
1281  { is.bread(&v, 1); }
1282  static void loadData(UT_IStream &is, bool &v)
1283  { int64 iv; is.bread(&iv, 1); v = iv; }
1284  static void loadData(UT_IStream &is, fpreal64 &v)
1285  { is.bread<fpreal64>(&v, 1); }
1286  static void loadData(UT_IStream &is, UT_Vector2D &v)
1287  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
1288  static void loadData(UT_IStream &is, UT_Vector3D &v)
1289  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1290  is.bread<fpreal64>(&v.z(), 1); }
1291  static void loadData(UT_IStream &is, UT_Vector4D &v)
1292  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
1293  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
1294  static void loadData(UT_IStream &is, UT_Matrix2D &v)
1295  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
1296  static void loadData(UT_IStream &is, UT_Matrix3D &v)
1297  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
1298  static void loadData(UT_IStream &is, UT_Matrix4D &v)
1299  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
1300  static void loadData(UT_IStream &is, UT_Vector2I &v)
1301  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
1302  static void loadData(UT_IStream &is, UT_Vector3I &v)
1303  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1304  is.bread<int64>(&v.z(), 1); }
1305  static void loadData(UT_IStream &is, UT_Vector4I &v)
1306  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
1307  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
1308  static void loadData(UT_IStream &is, UT_StringHolder &v)
1309  { is.bread(v); }
1310  static void loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
1311  { UT_StringHolder rampdata;
1312  loadData(is, rampdata);
1313  if (rampdata.isstring())
1314  {
1315  v.reset(new UT_Ramp());
1316  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
1317  v->load(istr);
1318  }
1319  else v.reset();
1320  }
1321  static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
1322  { UT_StringHolder data;
1323  loadData(is, data);
1324  if (data.isstring())
1325  {
1326  // Find the data type.
1327  const char *colon = UT_StringWrap(data).findChar(':');
1328  if (colon)
1329  {
1330  int typelen = colon - data.buffer();
1331  UT_WorkBuffer type;
1332  type.strncpy(data.buffer(), typelen);
1333  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
1334 
1335  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
1336  }
1337  }
1338  else v.reset();
1339  }
1340 
1341  static void saveData(std::ostream &os, int64 v)
1342  { UTwrite(os, &v); }
1343  static void saveData(std::ostream &os, bool v)
1344  { int64 iv = v; UTwrite(os, &iv); }
1345  static void saveData(std::ostream &os, fpreal64 v)
1346  { UTwrite<fpreal64>(os, &v); }
1347  static void saveData(std::ostream &os, UT_Vector2D v)
1348  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
1349  static void saveData(std::ostream &os, UT_Vector3D v)
1350  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1351  UTwrite<fpreal64>(os, &v.z()); }
1352  static void saveData(std::ostream &os, UT_Vector4D v)
1353  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
1354  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
1355  static void saveData(std::ostream &os, UT_Matrix2D v)
1356  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1357  static void saveData(std::ostream &os, UT_Matrix3D v)
1358  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1359  static void saveData(std::ostream &os, UT_Matrix4D v)
1360  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
1361  static void saveData(std::ostream &os, UT_StringHolder s)
1362  { UT_StringWrap(s).saveBinary(os); }
1363  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
1364  { UT_StringHolder result;
1365  UT_OStringStream ostr;
1366  if (s) s->save(ostr);
1367  result = ostr.str();
1368  saveData(os, result);
1369  }
1370  static void saveData(std::ostream &os, PRM_DataItemHandle s)
1371  { UT_StringHolder result;
1372  UT_OStringStream ostr;
1373  if (s)
1374  {
1375  ostr << s->getDataTypeToken();
1376  ostr << ":";
1377  s->saveBinary(ostr);
1378  }
1379  result = ostr.str();
1380  saveData(os, result);
1381  }
1382 
1383 
1384  void save(std::ostream &os) const
1385  {
1386  int32 v = version();
1387  UTwrite(os, &v);
1388  saveData(os, myCheckUpstream);
1389  saveData(os, myOutputAttrib);
1390  saveData(os, myCheckAttrib);
1391  saveData(os, myAttribName);
1392  {
1393  int64 length = myNumInputs.entries();
1394  UTwrite(os, &length);
1395  for (exint i = 0; i < length; i++)
1396  {
1397  auto && _curentry = myNumInputs(i);
1398  (void) _curentry;
1399  saveData(os, _curentry.input_enable);
1400  saveData(os, _curentry.input_checkpointattribs);
1401  saveData(os, _curentry.input_pointattribs);
1402  saveData(os, _curentry.input_checkvertexattribs);
1403  saveData(os, _curentry.input_vertexattribs);
1404  saveData(os, _curentry.input_checkprimitiveattribs);
1405  saveData(os, _curentry.input_primitiveattribs);
1406  saveData(os, _curentry.input_checkdetailattribs);
1407  saveData(os, _curentry.input_detailattribs);
1408  saveData(os, _curentry.input_checkpointgroups);
1409  saveData(os, _curentry.input_pointgroups);
1410  saveData(os, _curentry.input_checkvertexgroups);
1411  saveData(os, _curentry.input_vertexgroups);
1412  saveData(os, _curentry.input_checkprimitivegroups);
1413  saveData(os, _curentry.input_primitivegroups);
1414  saveData(os, _curentry.input_checkedgegroups);
1415  saveData(os, _curentry.input_edgegroups);
1416  saveData(os, _curentry.input_checkdetailid);
1417  saveData(os, _curentry.input_checkprimitivesid);
1418  saveData(os, _curentry.input_checktopology);
1419  saveData(os, _curentry.input_checkchangecount);
1420 
1421  }
1422  }
1423  saveData(os, myCheckGroups);
1424  {
1425  int64 length = myNumPatterns.entries();
1426  UTwrite(os, &length);
1427  for (exint i = 0; i < length; i++)
1428  {
1429  auto && _curentry = myNumPatterns(i);
1430  (void) _curentry;
1431  saveData(os, _curentry.parm_enable);
1432  saveData(os, _curentry.parm_nodepath);
1433  saveData(os, _curentry.parm_parmfilter);
1434  saveData(os, _curentry.parm_expandmultiparms);
1435  saveData(os, _curentry.parm_groupfilter);
1436  saveData(os, _curentry.parm_grouptype);
1437  saveData(os, _curentry.parm_oninput);
1438 
1439  }
1440  }
1441  {
1442  int64 length = myNumExpressions.entries();
1443  UTwrite(os, &length);
1444  for (exint i = 0; i < length; i++)
1445  {
1446  auto && _curentry = myNumExpressions(i);
1447  (void) _curentry;
1448  saveData(os, _curentry.expr_enable);
1449  saveData(os, _curentry.expr_cachewhen);
1450  saveData(os, _curentry.expr_exprval);
1451  saveData(os, _curentry.expr_exprtype);
1452  saveData(os, _curentry.expr_numexpr);
1453  saveData(os, _curentry.expr_strexpr);
1454 
1455  }
1456  }
1457 
1458  }
1459 
1460  bool load(UT_IStream &is)
1461  {
1462  int32 v;
1463  is.bread(&v, 1);
1464  if (version() != v)
1465  {
1466  // Fail incompatible versions
1467  return false;
1468  }
1469  loadData(is, myCheckUpstream);
1470  loadData(is, myOutputAttrib);
1471  loadData(is, myCheckAttrib);
1472  loadData(is, myAttribName);
1473  {
1474  int64 length;
1475  is.read(&length, 1);
1476  myNumInputs.setSize(length);
1477  for (exint i = 0; i < length; i++)
1478  {
1479  auto && _curentry = myNumInputs(i);
1480  (void) _curentry;
1481  loadData(is, _curentry.input_enable);
1482  loadData(is, _curentry.input_checkpointattribs);
1483  loadData(is, _curentry.input_pointattribs);
1484  loadData(is, _curentry.input_checkvertexattribs);
1485  loadData(is, _curentry.input_vertexattribs);
1486  loadData(is, _curentry.input_checkprimitiveattribs);
1487  loadData(is, _curentry.input_primitiveattribs);
1488  loadData(is, _curentry.input_checkdetailattribs);
1489  loadData(is, _curentry.input_detailattribs);
1490  loadData(is, _curentry.input_checkpointgroups);
1491  loadData(is, _curentry.input_pointgroups);
1492  loadData(is, _curentry.input_checkvertexgroups);
1493  loadData(is, _curentry.input_vertexgroups);
1494  loadData(is, _curentry.input_checkprimitivegroups);
1495  loadData(is, _curentry.input_primitivegroups);
1496  loadData(is, _curentry.input_checkedgegroups);
1497  loadData(is, _curentry.input_edgegroups);
1498  loadData(is, _curentry.input_checkdetailid);
1499  loadData(is, _curentry.input_checkprimitivesid);
1500  loadData(is, _curentry.input_checktopology);
1501  loadData(is, _curentry.input_checkchangecount);
1502 
1503  }
1504  }
1505  loadData(is, myCheckGroups);
1506  {
1507  int64 length;
1508  is.read(&length, 1);
1509  myNumPatterns.setSize(length);
1510  for (exint i = 0; i < length; i++)
1511  {
1512  auto && _curentry = myNumPatterns(i);
1513  (void) _curentry;
1514  loadData(is, _curentry.parm_enable);
1515  loadData(is, _curentry.parm_nodepath);
1516  loadData(is, _curentry.parm_parmfilter);
1517  loadData(is, _curentry.parm_expandmultiparms);
1518  loadData(is, _curentry.parm_groupfilter);
1519  loadData(is, _curentry.parm_grouptype);
1520  loadData(is, _curentry.parm_oninput);
1521 
1522  }
1523  }
1524  {
1525  int64 length;
1526  is.read(&length, 1);
1527  myNumExpressions.setSize(length);
1528  for (exint i = 0; i < length; i++)
1529  {
1530  auto && _curentry = myNumExpressions(i);
1531  (void) _curentry;
1532  loadData(is, _curentry.expr_enable);
1533  loadData(is, _curentry.expr_cachewhen);
1534  loadData(is, _curentry.expr_exprval);
1535  loadData(is, _curentry.expr_exprtype);
1536  loadData(is, _curentry.expr_numexpr);
1537  loadData(is, _curentry.expr_strexpr);
1538 
1539  }
1540  }
1541 
1542  return true;
1543  }
1544 
1545  bool getCheckUpstream() const { return myCheckUpstream; }
1546  void setCheckUpstream(bool val) { myCheckUpstream = val; }
1547  bool opCheckUpstream(const SOP_NodeVerb::CookParms &cookparms) const
1548  {
1549  SOP_Node *thissop = cookparms.getNode();
1550  if (!thissop) return getCheckUpstream();
1551  bool result;
1552  OP_Utils::evalOpParm(result, thissop, "checkupstream", cookparms.getCookTime(), 0);
1553  return result;
1554  }
1555  bool getOutputAttrib() const { return myOutputAttrib; }
1556  void setOutputAttrib(bool val) { myOutputAttrib = val; }
1557  bool opOutputAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1558  {
1559  SOP_Node *thissop = cookparms.getNode();
1560  if (!thissop) return getOutputAttrib();
1561  bool result;
1562  OP_Utils::evalOpParm(result, thissop, "outputattrib", cookparms.getCookTime(), 0);
1563  return result;
1564  }
1565  bool getCheckAttrib() const { return myCheckAttrib; }
1566  void setCheckAttrib(bool val) { myCheckAttrib = val; }
1567  bool opCheckAttrib(const SOP_NodeVerb::CookParms &cookparms) const
1568  {
1569  SOP_Node *thissop = cookparms.getNode();
1570  if (!thissop) return getCheckAttrib();
1571  bool result;
1572  OP_Utils::evalOpParm(result, thissop, "checkattrib", cookparms.getCookTime(), 0);
1573  return result;
1574  }
1575  const UT_StringHolder & getAttribName() const { return myAttribName; }
1576  void setAttribName(const UT_StringHolder & val) { myAttribName = val; }
1577  UT_StringHolder opAttribName(const SOP_NodeVerb::CookParms &cookparms) const
1578  {
1579  SOP_Node *thissop = cookparms.getNode();
1580  if (!thissop) return getAttribName();
1581  UT_StringHolder result;
1582  OP_Utils::evalOpParm(result, thissop, "attribname", cookparms.getCookTime(), 0);
1583  return result;
1584  }
1585  const UT_Array<NumInputs> &getNumInputs() const { return myNumInputs; }
1586 void setNumInputs(const UT_Array<NumInputs> &val) { myNumInputs = val; }
1587  exint opNumInputs(const SOP_NodeVerb::CookParms &cookparms) const
1588  {
1589  SOP_Node *thissop = cookparms.getNode();
1590  if (!thissop) return getNumInputs().entries();
1591  exint result;
1592  OP_Utils::evalOpParm(result, thissop, "numinputs", cookparms.getCookTime(), 0);
1593  return result;
1594  }
1595  bool opNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1596  { return opinstNumInputs_input_enable(cookparms, &_idx); }
1597  bool opinstNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1598  {
1599  SOP_Node *thissop = cookparms.getNode();
1600  if (!thissop) return (myNumInputs(_idx[0]).input_enable);
1601  int _parmidx[2-1];
1602  _parmidx[1-1] = _idx[1-1] + 1;
1603 
1604  bool result;
1605  OP_Utils::evalOpParmInst(result, thissop, "input_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1606  return (result);
1607  }
1608  bool opNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1609  { return opinstNumInputs_input_checkpointattribs(cookparms, &_idx); }
1610  bool opinstNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1611  {
1612  SOP_Node *thissop = cookparms.getNode();
1613  if (!thissop) return (myNumInputs(_idx[0]).input_checkpointattribs);
1614  int _parmidx[2-1];
1615  _parmidx[1-1] = _idx[1-1] + 1;
1616 
1617  bool result;
1618  OP_Utils::evalOpParmInst(result, thissop, "input_checkpointattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1619  return (result);
1620  }
1621  UT_StringHolder opNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1622  { return opinstNumInputs_input_pointattribs(cookparms, &_idx); }
1623  UT_StringHolder opinstNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1624  {
1625  SOP_Node *thissop = cookparms.getNode();
1626  if (!thissop) return (myNumInputs(_idx[0]).input_pointattribs);
1627  int _parmidx[2-1];
1628  _parmidx[1-1] = _idx[1-1] + 1;
1629 
1630  UT_StringHolder result;
1631  OP_Utils::evalOpParmInst(result, thissop, "input_pointattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1632  return (result);
1633  }
1634  bool opNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1635  { return opinstNumInputs_input_checkvertexattribs(cookparms, &_idx); }
1636  bool opinstNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1637  {
1638  SOP_Node *thissop = cookparms.getNode();
1639  if (!thissop) return (myNumInputs(_idx[0]).input_checkvertexattribs);
1640  int _parmidx[2-1];
1641  _parmidx[1-1] = _idx[1-1] + 1;
1642 
1643  bool result;
1644  OP_Utils::evalOpParmInst(result, thissop, "input_checkvertexattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1645  return (result);
1646  }
1647  UT_StringHolder opNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1648  { return opinstNumInputs_input_vertexattribs(cookparms, &_idx); }
1649  UT_StringHolder opinstNumInputs_input_vertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1650  {
1651  SOP_Node *thissop = cookparms.getNode();
1652  if (!thissop) return (myNumInputs(_idx[0]).input_vertexattribs);
1653  int _parmidx[2-1];
1654  _parmidx[1-1] = _idx[1-1] + 1;
1655 
1656  UT_StringHolder result;
1657  OP_Utils::evalOpParmInst(result, thissop, "input_vertexattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1658  return (result);
1659  }
1660  bool opNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1661  { return opinstNumInputs_input_checkprimitiveattribs(cookparms, &_idx); }
1662  bool opinstNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1663  {
1664  SOP_Node *thissop = cookparms.getNode();
1665  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitiveattribs);
1666  int _parmidx[2-1];
1667  _parmidx[1-1] = _idx[1-1] + 1;
1668 
1669  bool result;
1670  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitiveattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1671  return (result);
1672  }
1673  UT_StringHolder opNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1674  { return opinstNumInputs_input_primitiveattribs(cookparms, &_idx); }
1675  UT_StringHolder opinstNumInputs_input_primitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1676  {
1677  SOP_Node *thissop = cookparms.getNode();
1678  if (!thissop) return (myNumInputs(_idx[0]).input_primitiveattribs);
1679  int _parmidx[2-1];
1680  _parmidx[1-1] = _idx[1-1] + 1;
1681 
1682  UT_StringHolder result;
1683  OP_Utils::evalOpParmInst(result, thissop, "input_primitiveattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1684  return (result);
1685  }
1686  bool opNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1687  { return opinstNumInputs_input_checkdetailattribs(cookparms, &_idx); }
1688  bool opinstNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1689  {
1690  SOP_Node *thissop = cookparms.getNode();
1691  if (!thissop) return (myNumInputs(_idx[0]).input_checkdetailattribs);
1692  int _parmidx[2-1];
1693  _parmidx[1-1] = _idx[1-1] + 1;
1694 
1695  bool result;
1696  OP_Utils::evalOpParmInst(result, thissop, "input_checkdetailattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1697  return (result);
1698  }
1699  UT_StringHolder opNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1700  { return opinstNumInputs_input_detailattribs(cookparms, &_idx); }
1701  UT_StringHolder opinstNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1702  {
1703  SOP_Node *thissop = cookparms.getNode();
1704  if (!thissop) return (myNumInputs(_idx[0]).input_detailattribs);
1705  int _parmidx[2-1];
1706  _parmidx[1-1] = _idx[1-1] + 1;
1707 
1708  UT_StringHolder result;
1709  OP_Utils::evalOpParmInst(result, thissop, "input_detailattribs#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1710  return (result);
1711  }
1712  bool opNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1713  { return opinstNumInputs_input_checkpointgroups(cookparms, &_idx); }
1714  bool opinstNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1715  {
1716  SOP_Node *thissop = cookparms.getNode();
1717  if (!thissop) return (myNumInputs(_idx[0]).input_checkpointgroups);
1718  int _parmidx[2-1];
1719  _parmidx[1-1] = _idx[1-1] + 1;
1720 
1721  bool result;
1722  OP_Utils::evalOpParmInst(result, thissop, "input_checkpointgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1723  return (result);
1724  }
1725  UT_StringHolder opNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1726  { return opinstNumInputs_input_pointgroups(cookparms, &_idx); }
1727  UT_StringHolder opinstNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1728  {
1729  SOP_Node *thissop = cookparms.getNode();
1730  if (!thissop) return (myNumInputs(_idx[0]).input_pointgroups);
1731  int _parmidx[2-1];
1732  _parmidx[1-1] = _idx[1-1] + 1;
1733 
1734  UT_StringHolder result;
1735  OP_Utils::evalOpParmInst(result, thissop, "input_pointgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1736  return (result);
1737  }
1738  bool opNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1739  { return opinstNumInputs_input_checkvertexgroups(cookparms, &_idx); }
1740  bool opinstNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1741  {
1742  SOP_Node *thissop = cookparms.getNode();
1743  if (!thissop) return (myNumInputs(_idx[0]).input_checkvertexgroups);
1744  int _parmidx[2-1];
1745  _parmidx[1-1] = _idx[1-1] + 1;
1746 
1747  bool result;
1748  OP_Utils::evalOpParmInst(result, thissop, "input_checkvertexgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1749  return (result);
1750  }
1751  UT_StringHolder opNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1752  { return opinstNumInputs_input_vertexgroups(cookparms, &_idx); }
1753  UT_StringHolder opinstNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1754  {
1755  SOP_Node *thissop = cookparms.getNode();
1756  if (!thissop) return (myNumInputs(_idx[0]).input_vertexgroups);
1757  int _parmidx[2-1];
1758  _parmidx[1-1] = _idx[1-1] + 1;
1759 
1760  UT_StringHolder result;
1761  OP_Utils::evalOpParmInst(result, thissop, "input_vertexgroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1762  return (result);
1763  }
1764  bool opNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1765  { return opinstNumInputs_input_checkprimitivegroups(cookparms, &_idx); }
1766  bool opinstNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1767  {
1768  SOP_Node *thissop = cookparms.getNode();
1769  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitivegroups);
1770  int _parmidx[2-1];
1771  _parmidx[1-1] = _idx[1-1] + 1;
1772 
1773  bool result;
1774  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitivegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1775  return (result);
1776  }
1777  UT_StringHolder opNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1778  { return opinstNumInputs_input_primitivegroups(cookparms, &_idx); }
1779  UT_StringHolder opinstNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1780  {
1781  SOP_Node *thissop = cookparms.getNode();
1782  if (!thissop) return (myNumInputs(_idx[0]).input_primitivegroups);
1783  int _parmidx[2-1];
1784  _parmidx[1-1] = _idx[1-1] + 1;
1785 
1786  UT_StringHolder result;
1787  OP_Utils::evalOpParmInst(result, thissop, "input_primitivegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1788  return (result);
1789  }
1790  bool opNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1791  { return opinstNumInputs_input_checkedgegroups(cookparms, &_idx); }
1792  bool opinstNumInputs_input_checkedgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1793  {
1794  SOP_Node *thissop = cookparms.getNode();
1795  if (!thissop) return (myNumInputs(_idx[0]).input_checkedgegroups);
1796  int _parmidx[2-1];
1797  _parmidx[1-1] = _idx[1-1] + 1;
1798 
1799  bool result;
1800  OP_Utils::evalOpParmInst(result, thissop, "input_checkedgegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1801  return (result);
1802  }
1803  UT_StringHolder opNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1804  { return opinstNumInputs_input_edgegroups(cookparms, &_idx); }
1805  UT_StringHolder opinstNumInputs_input_edgegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1806  {
1807  SOP_Node *thissop = cookparms.getNode();
1808  if (!thissop) return (myNumInputs(_idx[0]).input_edgegroups);
1809  int _parmidx[2-1];
1810  _parmidx[1-1] = _idx[1-1] + 1;
1811 
1812  UT_StringHolder result;
1813  OP_Utils::evalOpParmInst(result, thissop, "input_edgegroups#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1814  return (result);
1815  }
1816  bool opNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1817  { return opinstNumInputs_input_checkdetailid(cookparms, &_idx); }
1818  bool opinstNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1819  {
1820  SOP_Node *thissop = cookparms.getNode();
1821  if (!thissop) return (myNumInputs(_idx[0]).input_checkdetailid);
1822  int _parmidx[2-1];
1823  _parmidx[1-1] = _idx[1-1] + 1;
1824 
1825  bool result;
1826  OP_Utils::evalOpParmInst(result, thissop, "input_checkdetailid#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1827  return (result);
1828  }
1829  bool opNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1830  { return opinstNumInputs_input_checkprimitivesid(cookparms, &_idx); }
1831  bool opinstNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1832  {
1833  SOP_Node *thissop = cookparms.getNode();
1834  if (!thissop) return (myNumInputs(_idx[0]).input_checkprimitivesid);
1835  int _parmidx[2-1];
1836  _parmidx[1-1] = _idx[1-1] + 1;
1837 
1838  bool result;
1839  OP_Utils::evalOpParmInst(result, thissop, "input_checkprimitivesid#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1840  return (result);
1841  }
1842  bool opNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1843  { return opinstNumInputs_input_checktopology(cookparms, &_idx); }
1844  bool opinstNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1845  {
1846  SOP_Node *thissop = cookparms.getNode();
1847  if (!thissop) return (myNumInputs(_idx[0]).input_checktopology);
1848  int _parmidx[2-1];
1849  _parmidx[1-1] = _idx[1-1] + 1;
1850 
1851  bool result;
1852  OP_Utils::evalOpParmInst(result, thissop, "input_checktopology#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1853  return (result);
1854  }
1855  bool opNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1856  { return opinstNumInputs_input_checkchangecount(cookparms, &_idx); }
1857  bool opinstNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1858  {
1859  SOP_Node *thissop = cookparms.getNode();
1860  if (!thissop) return (myNumInputs(_idx[0]).input_checkchangecount);
1861  int _parmidx[2-1];
1862  _parmidx[1-1] = _idx[1-1] + 1;
1863 
1864  bool result;
1865  OP_Utils::evalOpParmInst(result, thissop, "input_checkchangecount#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1866  return (result);
1867  }
1868 
1869  CheckGroups getCheckGroups() const { return CheckGroups(myCheckGroups); }
1870  void setCheckGroups(CheckGroups val) { myCheckGroups = int64(val); }
1871  CheckGroups opCheckGroups(const SOP_NodeVerb::CookParms &cookparms) const
1872  {
1873  SOP_Node *thissop = cookparms.getNode();
1874  if (!thissop) return getCheckGroups();
1875  int64 result;
1876  OP_Utils::evalOpParm(result, thissop, "checkgroups", cookparms.getCookTime(), 0);
1877  return CheckGroups(result);
1878  }
1879  const UT_Array<NumPatterns> &getNumPatterns() const { return myNumPatterns; }
1880 void setNumPatterns(const UT_Array<NumPatterns> &val) { myNumPatterns = val; }
1881  exint opNumPatterns(const SOP_NodeVerb::CookParms &cookparms) const
1882  {
1883  SOP_Node *thissop = cookparms.getNode();
1884  if (!thissop) return getNumPatterns().entries();
1885  exint result;
1886  OP_Utils::evalOpParm(result, thissop, "numpatterns", cookparms.getCookTime(), 0);
1887  return result;
1888  }
1889  bool opNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1890  { return opinstNumPatterns_parm_enable(cookparms, &_idx); }
1891  bool opinstNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1892  {
1893  SOP_Node *thissop = cookparms.getNode();
1894  if (!thissop) return (myNumPatterns(_idx[0]).parm_enable);
1895  int _parmidx[2-1];
1896  _parmidx[1-1] = _idx[1-1] + 1;
1897 
1898  bool result;
1899  OP_Utils::evalOpParmInst(result, thissop, "parm_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1900  return (result);
1901  }
1902  UT_StringHolder opNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1903  { return opinstNumPatterns_parm_nodepath(cookparms, &_idx); }
1904  UT_StringHolder opinstNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1905  {
1906  SOP_Node *thissop = cookparms.getNode();
1907  if (!thissop) return (myNumPatterns(_idx[0]).parm_nodepath);
1908  int _parmidx[2-1];
1909  _parmidx[1-1] = _idx[1-1] + 1;
1910 
1911  UT_StringHolder result;
1912  OP_Utils::evalOpParmInst(result, thissop, "parm_nodepath#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1913  return (result);
1914  }
1915  UT_StringHolder opNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1916  { return opinstNumPatterns_parm_parmfilter(cookparms, &_idx); }
1917  UT_StringHolder opinstNumPatterns_parm_parmfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1918  {
1919  SOP_Node *thissop = cookparms.getNode();
1920  if (!thissop) return (myNumPatterns(_idx[0]).parm_parmfilter);
1921  int _parmidx[2-1];
1922  _parmidx[1-1] = _idx[1-1] + 1;
1923 
1924  UT_StringHolder result;
1925  OP_Utils::evalOpParmInst(result, thissop, "parm_parmfilter#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1926  return (result);
1927  }
1928  bool opNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1929  { return opinstNumPatterns_parm_expandmultiparms(cookparms, &_idx); }
1930  bool opinstNumPatterns_parm_expandmultiparms(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1931  {
1932  SOP_Node *thissop = cookparms.getNode();
1933  if (!thissop) return (myNumPatterns(_idx[0]).parm_expandmultiparms);
1934  int _parmidx[2-1];
1935  _parmidx[1-1] = _idx[1-1] + 1;
1936 
1937  bool result;
1938  OP_Utils::evalOpParmInst(result, thissop, "parm_expandmultiparms#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1939  return (result);
1940  }
1941  UT_StringHolder opNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1942  { return opinstNumPatterns_parm_groupfilter(cookparms, &_idx); }
1943  UT_StringHolder opinstNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1944  {
1945  SOP_Node *thissop = cookparms.getNode();
1946  if (!thissop) return (myNumPatterns(_idx[0]).parm_groupfilter);
1947  int _parmidx[2-1];
1948  _parmidx[1-1] = _idx[1-1] + 1;
1949 
1950  UT_StringHolder result;
1951  OP_Utils::evalOpParmInst(result, thissop, "parm_groupfilter#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1952  return (result);
1953  }
1954  int64 opNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1955  { return opinstNumPatterns_parm_grouptype(cookparms, &_idx); }
1956  int64 opinstNumPatterns_parm_grouptype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1957  {
1958  SOP_Node *thissop = cookparms.getNode();
1959  if (!thissop) return (myNumPatterns(_idx[0]).parm_grouptype);
1960  int _parmidx[2-1];
1961  _parmidx[1-1] = _idx[1-1] + 1;
1962 
1963  int64 result;
1964  OP_Utils::evalOpParmInst(result, thissop, "parm_grouptype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1965  return (result);
1966  }
1967  int64 opNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1968  { return opinstNumPatterns_parm_oninput(cookparms, &_idx); }
1969  int64 opinstNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1970  {
1971  SOP_Node *thissop = cookparms.getNode();
1972  if (!thissop) return (myNumPatterns(_idx[0]).parm_oninput);
1973  int _parmidx[2-1];
1974  _parmidx[1-1] = _idx[1-1] + 1;
1975 
1976  int64 result;
1977  OP_Utils::evalOpParmInst(result, thissop, "parm_oninput#", _parmidx, cookparms.getCookTime(), 0, 2-1);
1978  return (result);
1979  }
1980 
1981  const UT_Array<NumExpressions> &getNumExpressions() const { return myNumExpressions; }
1982 void setNumExpressions(const UT_Array<NumExpressions> &val) { myNumExpressions = val; }
1983  exint opNumExpressions(const SOP_NodeVerb::CookParms &cookparms) const
1984  {
1985  SOP_Node *thissop = cookparms.getNode();
1986  if (!thissop) return getNumExpressions().entries();
1987  exint result;
1988  OP_Utils::evalOpParm(result, thissop, "numexpressions", cookparms.getCookTime(), 0);
1989  return result;
1990  }
1991  bool opNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
1992  { return opinstNumExpressions_expr_enable(cookparms, &_idx); }
1993  bool opinstNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
1994  {
1995  SOP_Node *thissop = cookparms.getNode();
1996  if (!thissop) return (myNumExpressions(_idx[0]).expr_enable);
1997  int _parmidx[2-1];
1998  _parmidx[1-1] = _idx[1-1] + 1;
1999 
2000  bool result;
2001  OP_Utils::evalOpParmInst(result, thissop, "expr_enable#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2002  return (result);
2003  }
2004  int64 opNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2005  { return opinstNumExpressions_expr_cachewhen(cookparms, &_idx); }
2006  int64 opinstNumExpressions_expr_cachewhen(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2007  {
2008  SOP_Node *thissop = cookparms.getNode();
2009  if (!thissop) return (myNumExpressions(_idx[0]).expr_cachewhen);
2010  int _parmidx[2-1];
2011  _parmidx[1-1] = _idx[1-1] + 1;
2012 
2013  int64 result;
2014  OP_Utils::evalOpParmInst(result, thissop, "expr_cachewhen#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2015  return (result);
2016  }
2017  int64 opNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2018  { return opinstNumExpressions_expr_exprval(cookparms, &_idx); }
2019  int64 opinstNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2020  {
2021  SOP_Node *thissop = cookparms.getNode();
2022  if (!thissop) return (myNumExpressions(_idx[0]).expr_exprval);
2023  int _parmidx[2-1];
2024  _parmidx[1-1] = _idx[1-1] + 1;
2025 
2026  int64 result;
2027  OP_Utils::evalOpParmInst(result, thissop, "expr_exprval#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2028  return (result);
2029  }
2030  int64 opNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2031  { return opinstNumExpressions_expr_exprtype(cookparms, &_idx); }
2032  int64 opinstNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2033  {
2034  SOP_Node *thissop = cookparms.getNode();
2035  if (!thissop) return (myNumExpressions(_idx[0]).expr_exprtype);
2036  int _parmidx[2-1];
2037  _parmidx[1-1] = _idx[1-1] + 1;
2038 
2039  int64 result;
2040  OP_Utils::evalOpParmInst(result, thissop, "expr_exprtype#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2041  return (result);
2042  }
2043  fpreal64 opNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2044  { return opinstNumExpressions_expr_numexpr(cookparms, &_idx); }
2045  fpreal64 opinstNumExpressions_expr_numexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2046  {
2047  SOP_Node *thissop = cookparms.getNode();
2048  if (!thissop) return (myNumExpressions(_idx[0]).expr_numexpr);
2049  int _parmidx[2-1];
2050  _parmidx[1-1] = _idx[1-1] + 1;
2051 
2052  fpreal64 result;
2053  OP_Utils::evalOpParmInst(result, thissop, "expr_numexpr#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2054  return (result);
2055  }
2056  UT_StringHolder opNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
2057  { return opinstNumExpressions_expr_strexpr(cookparms, &_idx); }
2058  UT_StringHolder opinstNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
2059  {
2060  SOP_Node *thissop = cookparms.getNode();
2061  if (!thissop) return (myNumExpressions(_idx[0]).expr_strexpr);
2062  int _parmidx[2-1];
2063  _parmidx[1-1] = _idx[1-1] + 1;
2064 
2065  UT_StringHolder result;
2066  OP_Utils::evalOpParmInst(result, thissop, "expr_strexpr#", _parmidx, cookparms.getCookTime(), 0, 2-1);
2067  return (result);
2068  }
2069 
2070 
2071 private:
2072  bool myCheckUpstream;
2073  bool myOutputAttrib;
2074  bool myCheckAttrib;
2075  UT_StringHolder myAttribName;
2076  UT_Array<NumInputs> myNumInputs;
2077  int64 myCheckGroups;
2078  UT_Array<NumPatterns> myNumPatterns;
2079  UT_Array<NumExpressions> myNumExpressions;
2080 
2081 };
SOP_CacheIfParms::opinstNumPatterns_parm_oninput
int64 opinstNumPatterns_parm_oninput(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1969
SOP_CacheIfParms::getCheckAttrib
bool getCheckAttrib() const
Definition: SOP_CacheIf.proto.h:1565
SOP_CacheIfParms::setNumPatterns
void setNumPatterns(const UT_Array< NumPatterns > &val)
Definition: SOP_CacheIf.proto.h:1880
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:1300
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Definition: SOP_CacheIf.proto.h:1294
SOP_CacheIfParms::setCheckGroups
void setCheckGroups(CheckGroups val)
Definition: SOP_CacheIf.proto.h:1870
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:1361
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:1020
SOP_CacheIfParms::setCheckUpstream
void setCheckUpstream(bool val)
Definition: SOP_CacheIf.proto.h:1546
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:1675
SOP_CacheIfParms::opinstNumInputs_input_enable
bool opinstNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1597
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:1345
SOP_CacheIfParms::getNumPatterns
const UT_Array< NumPatterns > & getNumPatterns() const
Definition: SOP_CacheIf.proto.h:1879
SOP_CacheIfParms::opNumInputs_input_checktopology
bool opNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1842
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix2D v)
Definition: SOP_CacheIf.proto.h:1355
SOP_GraphProxy.h
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
Definition: SOP_CacheIf.proto.h:811
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix3D v)
Definition: SOP_CacheIf.proto.h:1357
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:1298
UT_WorkBuffer
Definition: UT_WorkBuffer.h:74
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, PRM_DataItemHandle s)
Definition: SOP_CacheIf.proto.h:1370
SOP_CacheIfParms::opNumExpressions_expr_enable
bool opNumExpressions_expr_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1991
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector3D &v)
Definition: SOP_CacheIf.proto.h:1288
SOP_CacheIfParms::opinstNumInputs_input_checktopology
bool opinstNumInputs_input_checktopology(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1844
SOP_CacheIfParms::createString
UT_StringHolder createString(const UT_Array< NumInputs > &list) const
Definition: SOP_CacheIf.proto.h:184
OP_GraphProxy
Definition: OP_GraphProxy.h:32
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, int64 &v)
Definition: SOP_CacheIf.proto.h:1280
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_StringHolder &v)
Definition: SOP_CacheIf.proto.h:1308
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:1556
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:1943
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:62
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:1286
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:1753
SOP_CacheIfParms::load
bool load(UT_IStream &is)
Definition: SOP_CacheIf.proto.h:1460
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector4D v)
Definition: SOP_CacheIf.proto.h:1352
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:1712
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, int64 v)
Definition: SOP_CacheIf.proto.h:1341
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:1566
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:1321
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
Definition: SOP_CacheIf.proto.h:817
SOP_CacheIfParms::getAttribName
const UT_StringHolder & getAttribName() const
Definition: SOP_CacheIf.proto.h:1575
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:797
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:1012
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:1576
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:799
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:1855
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, fpreal64 &v)
Definition: SOP_CacheIf.proto.h:1284
SOP_CacheIfParms::getCheckGroups
CheckGroups getCheckGroups() const
Definition: SOP_CacheIf.proto.h:1869
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
Definition: SOP_CacheIf.proto.h:809
SOP_CacheIfParms::NumInputs::input_checktopology
bool input_checktopology
Definition: SOP_CacheIf.proto.h:121
result
**But if you need a result
Definition: thread.h:613
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:1928
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
Definition: SOP_CacheIf.proto.h:1028
SOP_CacheIfEnums::CheckGroups::COOK
SOP_CacheIfParms::operator!=
bool operator!=(const SOP_CacheIfParms &src) const
Definition: SOP_CacheIf.proto.h:418
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:803
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:1993
SOP_CacheIfParms::opinstNumInputs_input_checkdetailattribs
bool opinstNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1688
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:2043
UT_StringWrap
Definition: UT_String.h:1375
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:1282
SOP_CacheIfParms::opinstNumInputs_input_checkpointgroups
bool opinstNumInputs_input_checkpointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1714
SOP_CacheIfParms::opinstNumPatterns_parm_enable
bool opinstNumPatterns_parm_enable(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1891
SOP_CacheIfParms::opinstNumInputs_input_checkdetailid
bool opinstNumInputs_input_checkdetailid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1818
SOP_CacheIfParms::opNumExpressions_expr_strexpr
UT_StringHolder opNumExpressions_expr_strexpr(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2056
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
Definition: SOP_CacheIf.proto.h:1018
SOP_CacheIfParms::opNumInputs_input_enable
bool opNumInputs_input_enable(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1595
UT_Vector4T::x
constexpr SYS_FORCE_INLINE T & x() noexcept
Definition: UT_Vector4.h:491
SOP_CacheIfParms::setNumInputs
void setNumInputs(const UT_Array< NumInputs > &val)
Definition: SOP_CacheIf.proto.h:1586
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
Definition: SOP_CacheIf.proto.h:1030
SOP_CacheIfParms::getNestParmName
const char * getNestParmName(TempIndex fieldnum) const override
Definition: SOP_CacheIf.proto.h:1053
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:2045
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
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:1026
SOP_CacheIfParms::opNumInputs_input_checkdetailattribs
bool opNumInputs_input_checkdetailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1686
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector2D v)
Definition: SOP_CacheIf.proto.h:1347
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:1803
SOP_CacheIfParms::opinstNumPatterns_parm_nodepath
UT_StringHolder opinstNumPatterns_parm_nodepath(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1904
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
Definition: SOP_CacheIf.proto.h:801
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:2004
SOP_CacheIfParms::opNumPatterns
exint opNumPatterns(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1881
UT_StringHolder
Definition: UT_StringHolder.h:999
OP_NodeParms::TempIndex
Definition: OP_NodeParms.h:232
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
Definition: SOP_CacheIf.proto.h:1024
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:1302
SOP_CacheIfParms::opCheckUpstream
bool opCheckUpstream(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1547
SOP_CacheIfParms::opinstNumInputs_input_pointgroups
UT_StringHolder opinstNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1727
SOP_CacheIfParms::opCheckAttrib
bool opCheckAttrib(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1567
SOP_CacheIfParms::opinstNumInputs_input_primitivegroups
UT_StringHolder opinstNumInputs_input_primitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1779
SOP_CacheIfParms::opinstNumExpressions_expr_exprtype
int64 opinstNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2032
SOP_CacheIfParms::opNumExpressions
exint opNumExpressions(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1983
SOP_CacheIfParms::opOutputAttrib
bool opOutputAttrib(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1557
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:1805
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
Definition: SOP_CacheIf.proto.h:1363
SOP_CacheIfParms::isParmColorRamp
bool isParmColorRamp(exint idx) const override
Definition: SOP_CacheIf.proto.h:788
UT_StringRef::length
exint length() const
Definition: UT_StringHolder.h:749
SOP_CacheIfParms::opinstNumInputs_input_checkpointattribs
bool opinstNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1610
UT_ISTREAM_ASCII
Definition: UT_IStream.h:38
SOP_CacheIfParms::save
void save(std::ostream &os) const
Definition: SOP_CacheIf.proto.h:1384
SOP_CacheIfParms::getNumExpressions
const UT_Array< NumExpressions > & getNumExpressions() const
Definition: SOP_CacheIf.proto.h:1981
SOP_CacheIfParms::opNumInputs_input_detailattribs
UT_StringHolder opNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1699
UT_StringRef::buffer
SYS_FORCE_INLINE const char * buffer() const
Definition: UT_StringHolder.h:570
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:1305
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:1816
SOP_CacheIfParms::copyFrom
void copyFrom(const OP_NodeParms *src) override
Definition: SOP_CacheIf.proto.h:615
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:1930
SOP_CacheIfParms::doGetParmValue
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
Definition: SOP_CacheIf.proto.h:622
SOP_CacheIfParms::operator==
bool operator==(const SOP_CacheIfParms &src) const
Definition: SOP_CacheIf.proto.h:405
OP_NodeParms::ParmType
ParmType
Definition: OP_NodeParms.h:158
SOP_CacheIfParms::loadFromOpSubclass
void loadFromOpSubclass(const LoadParms &loadparms) override
Definition: SOP_CacheIf.proto.h:609
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
Definition: SOP_CacheIf.proto.h:813
SOP_CacheIfParms::opNumInputs
exint opNumInputs(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1587
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:1310
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:2006
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:1166
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
Definition: SOP_CacheIf.proto.h:1032
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
Definition: SOP_CacheIf.proto.h:1016
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:1917
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:1889
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:429
UT_WorkBuffer::strcat
SYS_FORCE_INLINE void strcat(const char *src)
Definition: UT_WorkBuffer.h:435
UT_String::saveBinary
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:296
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:1673
UT_Array::entries
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:648
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:822
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:1634
SOP_CacheIfParms::setNumExpressions
void setNumExpressions(const UT_Array< NumExpressions > &val)
Definition: SOP_CacheIf.proto.h:1982
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:1621
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:1956
SOP_CacheIfParms::opinstNumInputs_input_checkprimitivesid
bool opinstNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1831
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Vector3D v)
Definition: SOP_CacheIf.proto.h:1349
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Vector4D &v)
Definition: SOP_CacheIf.proto.h:1291
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:1777
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:1790
fpreal
fpreal64 fpreal
Definition: SYS_Types.h:277
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:1577
SOP_CacheIfParms::getOutputAttrib
bool getOutputAttrib() const
Definition: SOP_CacheIf.proto.h:1555
SOP_CacheIfParms::opinstNumInputs_input_checkchangecount
bool opinstNumInputs_input_checkchangecount(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1857
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:1649
UT_Ramp
Utility class for containing a color ramp.
Definition: UT_Ramp.h:92
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:618
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::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:1764
SOP_CacheIfParms::getNestNumParms
exint getNestNumParms(TempIndex idx) const override
Definition: SOP_CacheIf.proto.h:1035
SOP_CacheIfParms::opinstNumInputs_input_checkvertexgroups
bool opinstNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1740
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:1792
SOP_NodeVerb::CookParms::getCookTime
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:361
SOP_CacheIfParms::opNumInputs_input_pointgroups
UT_StringHolder opNumInputs_input_pointgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1725
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:1647
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:1915
SOP_NodeVerb::CookParms
Definition: SOP_NodeVerb.h:310
UT_StringWrap::findChar
const char * findChar(int c) const
Definition: UT_String.h:1395
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:1902
value
Definition: core.h:1131
SOP_CacheIfParms::opinstNumInputs_input_checkprimitiveattribs
bool opinstNumInputs_input_checkprimitiveattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1662
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
Definition: SOP_CacheIf.proto.h:807
SOP_CacheIfParms::opNumPatterns_parm_groupfilter
UT_StringHolder opNumPatterns_parm_groupfilter(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1941
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
Definition: SOP_CacheIf.proto.h:805
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:1954
SOP_CacheIfParms::opNumInputs_input_checkpointattribs
bool opNumInputs_input_checkpointattribs(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1608
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
Definition: SOP_CacheIf.proto.h:1014
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, bool v)
Definition: SOP_CacheIf.proto.h:1343
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:1585
OP_NodeParms::TempIndex::size
exint size() const
Definition: OP_NodeParms.h:250
type
type
Definition: core.h:1059
SOP_CacheIfParms::opinstNumInputs_input_checkvertexattribs
bool opinstNumInputs_input_checkvertexattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1636
SOP_CacheIfParms::opNumInputs_input_checkprimitivesid
bool opNumInputs_input_checkprimitivesid(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1829
SOP_CacheIfParms::opNumExpressions_expr_exprtype
int64 opNumExpressions_expr_exprtype(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2030
SOP_CacheIfParms::opNumInputs_input_checkvertexgroups
bool opNumInputs_input_checkvertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1738
SOP_CacheIfParms::opinstNumInputs_input_checkprimitivegroups
bool opinstNumInputs_input_checkprimitivegroups(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1766
SOP_CacheIfParms::opCheckGroups
CheckGroups opCheckGroups(const SOP_NodeVerb::CookParms &cookparms) const
Definition: SOP_CacheIf.proto.h:1871
PRM_DataItemHandle
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:97
SOP_CacheIfParms::setNestParmValue
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
Definition: SOP_CacheIf.proto.h:1022
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:2058
UT_StringRef::isstring
SYS_FORCE_INLINE bool isstring() const
Definition: UT_StringHolder.h:607
SOP_CacheIfParms::getCheckUpstream
bool getCheckUpstream() const
Definition: SOP_CacheIf.proto.h:1545
SOP_CacheIfParms::opinstNumInputs_input_detailattribs
UT_StringHolder opinstNumInputs_input_detailattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1701
SOP_CacheIfParms::saveData
static void saveData(std::ostream &os, UT_Matrix4D v)
Definition: SOP_CacheIf.proto.h:1359
SOP_Node
Definition: SOP_Node.h:108
SOP_CacheIfParms::opinstNumInputs_input_pointattribs
UT_StringHolder opinstNumInputs_input_pointattribs(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:1623
UT_WorkBuffer::strncpy
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
Definition: UT_WorkBuffer.h:409
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:1660
SOP_CacheIfParms::opinstNumExpressions_expr_exprval
int64 opinstNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, const int *_idx) const
Definition: SOP_CacheIf.proto.h:2019
SOP_CacheIfParms::opNumExpressions_expr_exprval
int64 opNumExpressions_expr_exprval(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:2017
SOP_CacheIfParms::loadData
static void loadData(UT_IStream &is, UT_Matrix3D &v)
Definition: SOP_CacheIf.proto.h:1296
SOP_CacheIfParms::getNestParmValue
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
Definition: SOP_CacheIf.proto.h:815
SOP_CacheIfParms::opNumInputs_input_vertexgroups
UT_StringHolder opNumInputs_input_vertexgroups(const SOP_NodeVerb::CookParms &cookparms, int _idx) const
Definition: SOP_CacheIf.proto.h:1751
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:1967
UT_Ramp.h