HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_Attribute.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_NodeVerb.h>
7 #include <OP/OP_Utils.h>
8 #include <PRM/PRM_Parm.h>
9 #include <UT/UT_IStream.h>
10 #include <UT/UT_NTStreamUtil.h>
11 #include <UT/UT_Ramp.h>
12 #include <UT/UT_SharedPtr.h>
13 #include <UT/UT_StringHolder.h>
14 #include <UT/UT_StringStream.h>
15 #include <UT/UT_VectorTypes.h>
16 #include <SYS/SYS_Types.h>
17 
18 using namespace UT::Literal;
19 
20 class DEP_MicroNode;
21 
23 {
24 public:
25  static int version() { return 1; }
26  struct Ptrenames
27  {
30 
31 
33  {
34  frompt = ""_sh;
35  topt = ""_sh;
36 
37  }
38 
39  bool operator==(const Ptrenames &src) const
40  {
41  if (frompt != src.frompt) return false;
42  if (topt != src.topt) return false;
43 
44  return true;
45  }
46 
47  };
48 
50  {
52 
53  buf.strcat("[ ");
54  for (int i = 0; i < list.entries(); i++)
55  {
56  if (i)
57  buf.strcat(", ");
58  buf.strcat("( ");
59  buf.append("");
60  { UT_String tmp; tmp = UT_StringWrap(list(i).frompt).makeQuotedString('"'); buf.strcat(tmp); }
61  buf.append(", ");
62  { UT_String tmp; tmp = UT_StringWrap(list(i).topt).makeQuotedString('"'); buf.strcat(tmp); }
63 
64  buf.strcat(" )");
65  }
66  buf.strcat(" ]");
67 
68  UT_StringHolder result = buf;
69  return result;
70  }
71  struct Vtxrenames
72  {
75 
76 
78  {
79  fromvtx = ""_sh;
80  tovtx = ""_sh;
81 
82  }
83 
84  bool operator==(const Vtxrenames &src) const
85  {
86  if (fromvtx != src.fromvtx) return false;
87  if (tovtx != src.tovtx) return false;
88 
89  return true;
90  }
91 
92  };
93 
95  {
97 
98  buf.strcat("[ ");
99  for (int i = 0; i < list.entries(); i++)
100  {
101  if (i)
102  buf.strcat(", ");
103  buf.strcat("( ");
104  buf.append("");
105  { UT_String tmp; tmp = UT_StringWrap(list(i).fromvtx).makeQuotedString('"'); buf.strcat(tmp); }
106  buf.append(", ");
107  { UT_String tmp; tmp = UT_StringWrap(list(i).tovtx).makeQuotedString('"'); buf.strcat(tmp); }
108 
109  buf.strcat(" )");
110  }
111  buf.strcat(" ]");
112 
113  UT_StringHolder result = buf;
114  return result;
115  }
116  struct Primrenames
117  {
120 
121 
123  {
124  frompr = ""_sh;
125  topr = ""_sh;
126 
127  }
128 
129  bool operator==(const Primrenames &src) const
130  {
131  if (frompr != src.frompr) return false;
132  if (topr != src.topr) return false;
133 
134  return true;
135  }
136 
137  };
138 
140  {
142 
143  buf.strcat("[ ");
144  for (int i = 0; i < list.entries(); i++)
145  {
146  if (i)
147  buf.strcat(", ");
148  buf.strcat("( ");
149  buf.append("");
150  { UT_String tmp; tmp = UT_StringWrap(list(i).frompr).makeQuotedString('"'); buf.strcat(tmp); }
151  buf.append(", ");
152  { UT_String tmp; tmp = UT_StringWrap(list(i).topr).makeQuotedString('"'); buf.strcat(tmp); }
153 
154  buf.strcat(" )");
155  }
156  buf.strcat(" ]");
157 
158  UT_StringHolder result = buf;
159  return result;
160  }
162  {
165 
166 
168  {
169  fromdtl = ""_sh;
170  todtl = ""_sh;
171 
172  }
173 
174  bool operator==(const Detailrenames &src) const
175  {
176  if (fromdtl != src.fromdtl) return false;
177  if (todtl != src.todtl) return false;
178 
179  return true;
180  }
181 
182  };
183 
185  {
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  { UT_String tmp; tmp = UT_StringWrap(list(i).fromdtl).makeQuotedString('"'); buf.strcat(tmp); }
196  buf.append(", ");
197  { UT_String tmp; tmp = UT_StringWrap(list(i).todtl).makeQuotedString('"'); buf.strcat(tmp); }
198 
199  buf.strcat(" )");
200  }
201  buf.strcat(" ]");
202 
203  UT_StringHolder result = buf;
204  return result;
205  }
207  {
212 
213 
215  {
216  hname = ""_sh;
217  riname = ""_sh;
218  ritype = "vtx_float"_sh;
219  rioff = 0;
220 
221  }
222 
223  bool operator==(const Rmanconversions &src) const
224  {
225  if (hname != src.hname) return false;
226  if (riname != src.riname) return false;
227  if (ritype != src.ritype) return false;
228  if (rioff != src.rioff) return false;
229 
230  return true;
231  }
232 
233  };
234 
236  {
238 
239  buf.strcat("[ ");
240  for (int i = 0; i < list.entries(); i++)
241  {
242  if (i)
243  buf.strcat(", ");
244  buf.strcat("( ");
245  buf.append("");
246  { UT_String tmp; tmp = UT_StringWrap(list(i).hname).makeQuotedString('"'); buf.strcat(tmp); }
247  buf.append(", ");
248  { UT_String tmp; tmp = UT_StringWrap(list(i).riname).makeQuotedString('"'); buf.strcat(tmp); }
249  buf.append(", ");
250  { UT_String tmp; tmp = UT_StringWrap(list(i).ritype).makeQuotedString('"'); buf.strcat(tmp); }
251  buf.append(", ");
252  buf.appendSprintf("%d", (int) list(i).rioff);
253 
254  buf.strcat(" )");
255  }
256  buf.strcat(" ]");
257 
258  UT_StringHolder result = buf;
259  return result;
260  }
261 
263  {
264  myPtdel = ""_sh;
265  myPtkeep = "*"_sh;
266  myVtxdel = ""_sh;
267  myVtxkeep = "*"_sh;
268  myPrimdel = ""_sh;
269  myPrimkeep = "*"_sh;
270  myDtldel = ""_sh;
271  myDtlkeep = "*"_sh;
272  myRidefault = false;
273  myUpdatevar = true;
274  myOverwrite = false;
275 
276  }
277 
278  explicit SOP_AttributeParms(const SOP_AttributeParms &) = default;
279 
280  virtual ~SOP_AttributeParms() {}
281 
282  bool operator==(const SOP_AttributeParms &src) const
283  {
284  if (myPtrenames != src.myPtrenames) return false;
285  if (myPtdel != src.myPtdel) return false;
286  if (myPtkeep != src.myPtkeep) return false;
287  if (myVtxrenames != src.myVtxrenames) return false;
288  if (myVtxdel != src.myVtxdel) return false;
289  if (myVtxkeep != src.myVtxkeep) return false;
290  if (myPrimrenames != src.myPrimrenames) return false;
291  if (myPrimdel != src.myPrimdel) return false;
292  if (myPrimkeep != src.myPrimkeep) return false;
293  if (myDetailrenames != src.myDetailrenames) return false;
294  if (myDtldel != src.myDtldel) return false;
295  if (myDtlkeep != src.myDtlkeep) return false;
296  if (myRmanconversions != src.myRmanconversions) return false;
297  if (myRidefault != src.myRidefault) return false;
298  if (myUpdatevar != src.myUpdatevar) return false;
299  if (myOverwrite != src.myOverwrite) return false;
300 
301  return true;
302  }
303 
304 
305 
306  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
307  {
308  if (true)
309  {
310  int64 length;
311  OP_Utils::evalOpParm(length, node, "ptrenames", time, 0);
312  myPtrenames.entries(length);
313  for (exint i = 0; i < length; i++)
314  {
315  int parmidx = i+0;
316  auto && _curentry = myPtrenames(i);
317  (void) _curentry;
318  if (true)
319  OP_Utils::evalOpParmInst(myPtrenames(i).frompt, node, "frompt#", &parmidx, time, 0);
320  else myPtrenames(i).frompt = ""_sh;
321  if (true)
322  OP_Utils::evalOpParmInst(myPtrenames(i).topt, node, "topt#", &parmidx, time, 0);
323  else myPtrenames(i).topt = ""_sh;
324 
325  }
326  }
327  else
328  myPtrenames.clear();
329  if (true)
330  OP_Utils::evalOpParm(myPtdel, node, "ptdel", time, 0);
331  else myPtdel = ""_sh;
332  if (true)
333  OP_Utils::evalOpParm(myPtkeep, node, "ptkeep", time, 0);
334  else myPtkeep = "*"_sh;
335  if (true)
336  {
337  int64 length;
338  OP_Utils::evalOpParm(length, node, "vtxrenames", time, 0);
339  myVtxrenames.entries(length);
340  for (exint i = 0; i < length; i++)
341  {
342  int parmidx = i+0;
343  auto && _curentry = myVtxrenames(i);
344  (void) _curentry;
345  if (true)
346  OP_Utils::evalOpParmInst(myVtxrenames(i).fromvtx, node, "fromvtx#", &parmidx, time, 0);
347  else myVtxrenames(i).fromvtx = ""_sh;
348  if (true)
349  OP_Utils::evalOpParmInst(myVtxrenames(i).tovtx, node, "tovtx#", &parmidx, time, 0);
350  else myVtxrenames(i).tovtx = ""_sh;
351 
352  }
353  }
354  else
355  myVtxrenames.clear();
356  if (true)
357  OP_Utils::evalOpParm(myVtxdel, node, "vtxdel", time, 0);
358  else myVtxdel = ""_sh;
359  if (true)
360  OP_Utils::evalOpParm(myVtxkeep, node, "vtxkeep", time, 0);
361  else myVtxkeep = "*"_sh;
362  if (true)
363  {
364  int64 length;
365  OP_Utils::evalOpParm(length, node, "primrenames", time, 0);
366  myPrimrenames.entries(length);
367  for (exint i = 0; i < length; i++)
368  {
369  int parmidx = i+0;
370  auto && _curentry = myPrimrenames(i);
371  (void) _curentry;
372  if (true)
373  OP_Utils::evalOpParmInst(myPrimrenames(i).frompr, node, "frompr#", &parmidx, time, 0);
374  else myPrimrenames(i).frompr = ""_sh;
375  if (true)
376  OP_Utils::evalOpParmInst(myPrimrenames(i).topr, node, "topr#", &parmidx, time, 0);
377  else myPrimrenames(i).topr = ""_sh;
378 
379  }
380  }
381  else
382  myPrimrenames.clear();
383  if (true)
384  OP_Utils::evalOpParm(myPrimdel, node, "primdel", time, 0);
385  else myPrimdel = ""_sh;
386  if (true)
387  OP_Utils::evalOpParm(myPrimkeep, node, "primkeep", time, 0);
388  else myPrimkeep = "*"_sh;
389  if (true)
390  {
391  int64 length;
392  OP_Utils::evalOpParm(length, node, "detailrenames", time, 0);
393  myDetailrenames.entries(length);
394  for (exint i = 0; i < length; i++)
395  {
396  int parmidx = i+0;
397  auto && _curentry = myDetailrenames(i);
398  (void) _curentry;
399  if (true)
400  OP_Utils::evalOpParmInst(myDetailrenames(i).fromdtl, node, "fromdtl#", &parmidx, time, 0);
401  else myDetailrenames(i).fromdtl = ""_sh;
402  if (true)
403  OP_Utils::evalOpParmInst(myDetailrenames(i).todtl, node, "todtl#", &parmidx, time, 0);
404  else myDetailrenames(i).todtl = ""_sh;
405 
406  }
407  }
408  else
409  myDetailrenames.clear();
410  if (true)
411  OP_Utils::evalOpParm(myDtldel, node, "dtldel", time, 0);
412  else myDtldel = ""_sh;
413  if (true)
414  OP_Utils::evalOpParm(myDtlkeep, node, "dtlkeep", time, 0);
415  else myDtlkeep = "*"_sh;
416  if (true)
417  {
418  int64 length;
419  OP_Utils::evalOpParm(length, node, "rmanconversions", time, 0);
420  myRmanconversions.entries(length);
421  for (exint i = 0; i < length; i++)
422  {
423  int parmidx = i+0;
424  auto && _curentry = myRmanconversions(i);
425  (void) _curentry;
426  if (true)
427  OP_Utils::evalOpParmInst(myRmanconversions(i).hname, node, "hname#", &parmidx, time, 0);
428  else myRmanconversions(i).hname = ""_sh;
429  if (true)
430  OP_Utils::evalOpParmInst(myRmanconversions(i).riname, node, "riname#", &parmidx, time, 0);
431  else myRmanconversions(i).riname = ""_sh;
432  if (true)
433  OP_Utils::evalOpParmInst(myRmanconversions(i).ritype, node, "ritype#", &parmidx, time, 0);
434  else myRmanconversions(i).ritype = "vtx_float"_sh;
435  if (true)
436  OP_Utils::evalOpParmInst(myRmanconversions(i).rioff, node, "rioff#", &parmidx, time, 0);
437  else myRmanconversions(i).rioff = 0;
438 
439  }
440  }
441  else
442  myRmanconversions.clear();
443  if (true)
444  OP_Utils::evalOpParm(myRidefault, node, "ridefault", time, 0);
445  else myRidefault = false;
446  if (true)
447  OP_Utils::evalOpParm(myUpdatevar, node, "updatevar", time, 0);
448  else myUpdatevar = true;
449  if (true)
450  OP_Utils::evalOpParm(myOverwrite, node, "overwrite", time, 0);
451  else myOverwrite = false;
452 
453  }
454 
455 
456  virtual void loadFromOpSubclass(const LoadParms &loadparms)
457  {
458  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
459  }
460 
461 
462  virtual void copyFrom(const SOP_NodeParms *src)
463  {
464  *this = *((const SOP_AttributeParms *)src);
465  }
466 
467  template <typename T>
468  void
469  doGetParmValue(exint idx, T &value) const
470  {
471  switch (idx)
472  {
473  case 1:
474  coerceValue(value, myPtdel);
475  break;
476  case 2:
477  coerceValue(value, myPtkeep);
478  break;
479  case 4:
480  coerceValue(value, myVtxdel);
481  break;
482  case 5:
483  coerceValue(value, myVtxkeep);
484  break;
485  case 7:
486  coerceValue(value, myPrimdel);
487  break;
488  case 8:
489  coerceValue(value, myPrimkeep);
490  break;
491  case 10:
492  coerceValue(value, myDtldel);
493  break;
494  case 11:
495  coerceValue(value, myDtlkeep);
496  break;
497  case 13:
498  coerceValue(value, myRidefault);
499  break;
500  case 14:
501  coerceValue(value, myUpdatevar);
502  break;
503  case 15:
504  coerceValue(value, myOverwrite);
505  break;
506 
507  }
508  }
509 
510  void getParmValue(exint idx, exint &value) const
511  { doGetParmValue(idx, value); }
512  void getParmValue(exint idx, fpreal &value) const
513  { doGetParmValue(idx, value); }
515  { doGetParmValue(idx, value); }
517  { doGetParmValue(idx, value); }
519  { doGetParmValue(idx, value); }
521  { doGetParmValue(idx, value); }
523  { doGetParmValue(idx, value); }
525  { doGetParmValue(idx, value); }
527  { doGetParmValue(idx, value); }
529  { doGetParmValue(idx, value); }
531  { doGetParmValue(idx, value); }
532 
533  template <typename T>
534  void
535  doSetParmValue(exint idx, const T &value)
536  {
537  switch (idx)
538  {
539  case 1:
540  coerceValue(myPtdel, value);
541  break;
542  case 2:
543  coerceValue(myPtkeep, value);
544  break;
545  case 4:
546  coerceValue(myVtxdel, value);
547  break;
548  case 5:
549  coerceValue(myVtxkeep, value);
550  break;
551  case 7:
552  coerceValue(myPrimdel, value);
553  break;
554  case 8:
555  coerceValue(myPrimkeep, value);
556  break;
557  case 10:
558  coerceValue(myDtldel, value);
559  break;
560  case 11:
561  coerceValue(myDtlkeep, value);
562  break;
563  case 13:
564  coerceValue(myRidefault, value);
565  break;
566  case 14:
567  coerceValue(myUpdatevar, value);
568  break;
569  case 15:
570  coerceValue(myOverwrite, value);
571  break;
572 
573  }
574  }
575 
576  void setParmValue(exint idx, const exint &value)
577  { doSetParmValue(idx, value); }
578  void setParmValue(exint idx, const fpreal &value)
579  { doSetParmValue(idx, value); }
580  void setParmValue(exint idx, const UT_Vector2D &value)
581  { doSetParmValue(idx, value); }
582  void setParmValue(exint idx, const UT_Vector3D &value)
583  { doSetParmValue(idx, value); }
584  void setParmValue(exint idx, const UT_Vector4D &value)
585  { doSetParmValue(idx, value); }
586  void setParmValue(exint idx, const UT_Matrix2D &value)
587  { doSetParmValue(idx, value); }
588  void setParmValue(exint idx, const UT_Matrix3D &value)
589  { doSetParmValue(idx, value); }
590  void setParmValue(exint idx, const UT_Matrix4D &value)
591  { doSetParmValue(idx, value); }
593  { doSetParmValue(idx, value); }
595  { doSetParmValue(idx, value); }
597  { doSetParmValue(idx, value); }
598 
599  virtual exint getNumParms() const
600  {
601  return 16;
602  }
603 
604  virtual const char *getParmName(exint fieldnum) const
605  {
606  switch (fieldnum)
607  {
608  case 0:
609  return "ptrenames";
610  case 1:
611  return "ptdel";
612  case 2:
613  return "ptkeep";
614  case 3:
615  return "vtxrenames";
616  case 4:
617  return "vtxdel";
618  case 5:
619  return "vtxkeep";
620  case 6:
621  return "primrenames";
622  case 7:
623  return "primdel";
624  case 8:
625  return "primkeep";
626  case 9:
627  return "detailrenames";
628  case 10:
629  return "dtldel";
630  case 11:
631  return "dtlkeep";
632  case 12:
633  return "rmanconversions";
634  case 13:
635  return "ridefault";
636  case 14:
637  return "updatevar";
638  case 15:
639  return "overwrite";
640 
641  }
642  return 0;
643  }
644 
645  virtual ParmType getParmType(exint fieldnum) const
646  {
647  switch (fieldnum)
648  {
649  case 1:
650  return PARM_STRING;
651  case 2:
652  return PARM_STRING;
653  case 4:
654  return PARM_STRING;
655  case 5:
656  return PARM_STRING;
657  case 7:
658  return PARM_STRING;
659  case 8:
660  return PARM_STRING;
661  case 10:
662  return PARM_STRING;
663  case 11:
664  return PARM_STRING;
665  case 13:
666  return PARM_INTEGER;
667  case 14:
668  return PARM_INTEGER;
669  case 15:
670  return PARM_INTEGER;
671 
672  }
673  return PARM_UNSUPPORTED;
674  }
675 
676  // Boiler plate to load individual types.
677  static void loadData(UT_IStream &is, int64 &v)
678  { is.bread(&v, 1); }
679  static void loadData(UT_IStream &is, bool &v)
680  { int64 iv; is.bread(&iv, 1); v = iv; }
681  static void loadData(UT_IStream &is, fpreal64 &v)
682  { is.bread<fpreal64>(&v, 1); }
683  static void loadData(UT_IStream &is, UT_Vector2D &v)
684  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
685  static void loadData(UT_IStream &is, UT_Vector3D &v)
686  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
687  is.bread<fpreal64>(&v.z(), 1); }
688  static void loadData(UT_IStream &is, UT_Vector4D &v)
689  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
690  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
691  static void loadData(UT_IStream &is, UT_Matrix2D &v)
692  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
693  static void loadData(UT_IStream &is, UT_Matrix3D &v)
694  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
695  static void loadData(UT_IStream &is, UT_Matrix4D &v)
696  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
697  static void loadData(UT_IStream &is, UT_Vector2I &v)
698  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
699  static void loadData(UT_IStream &is, UT_Vector3I &v)
700  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
701  is.bread<int64>(&v.z(), 1); }
702  static void loadData(UT_IStream &is, UT_Vector4I &v)
703  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
704  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
706  { is.bread(v); }
708  { UT_StringHolder rampdata;
709  loadData(is, rampdata);
710  if (rampdata.isstring())
711  {
712  v.reset(new UT_Ramp());
713  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
714  v->load(istr);
715  }
716  else v.reset();
717  }
720  loadData(is, data);
721  if (data.isstring())
722  {
723  // Find the data type.
724  char *colon = UT_StringWrap(data).findChar(':');
725  if (colon)
726  {
727  int typelen = colon - data.buffer();
729  type.strncpy(data.buffer(), typelen);
730  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
731 
732  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
733  }
734  }
735  else v.reset();
736  }
737 
738  static void saveData(std::ostream &os, int64 v)
739  { UTwrite(os, &v); }
740  static void saveData(std::ostream &os, bool v)
741  { int64 iv = v; UTwrite(os, &iv); }
742  static void saveData(std::ostream &os, fpreal64 v)
743  { UTwrite<fpreal64>(os, &v); }
744  static void saveData(std::ostream &os, UT_Vector2D v)
745  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
746  static void saveData(std::ostream &os, UT_Vector3D v)
747  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
748  UTwrite<fpreal64>(os, &v.z()); }
749  static void saveData(std::ostream &os, UT_Vector4D v)
750  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
751  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
752  static void saveData(std::ostream &os, UT_Matrix2D v)
754  static void saveData(std::ostream &os, UT_Matrix3D v)
756  static void saveData(std::ostream &os, UT_Matrix4D v)
758  static void saveData(std::ostream &os, UT_StringHolder s)
759  { UT_StringWrap(s).saveBinary(os); }
760  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
761  { UT_StringHolder result;
762  UT_OStringStream ostr;
763  if (s) s->save(ostr);
764  result = ostr.str();
765  saveData(os, result);
766  }
767  static void saveData(std::ostream &os, PRM_DataItemHandle s)
768  { UT_StringHolder result;
769  UT_OStringStream ostr;
770  if (s)
771  {
772  ostr << s->getDataTypeToken();
773  ostr << ":";
774  s->saveBinary(ostr);
775  }
776  result = ostr.str();
777  saveData(os, result);
778  }
779 
780 
781  void save(std::ostream &os) const
782  {
783  int32 v = version();
784  UTwrite(os, &v);
785  {
786  int64 length = myPtrenames.entries();
787  UTwrite(os, &length);
788  for (exint i = 0; i < length; i++)
789  {
790  saveData(os, myPtrenames(i).frompt);
791  saveData(os, myPtrenames(i).topt);
792 
793  }
794  }
795  saveData(os, myPtdel);
796  saveData(os, myPtkeep);
797  {
798  int64 length = myVtxrenames.entries();
799  UTwrite(os, &length);
800  for (exint i = 0; i < length; i++)
801  {
802  saveData(os, myVtxrenames(i).fromvtx);
803  saveData(os, myVtxrenames(i).tovtx);
804 
805  }
806  }
807  saveData(os, myVtxdel);
808  saveData(os, myVtxkeep);
809  {
810  int64 length = myPrimrenames.entries();
811  UTwrite(os, &length);
812  for (exint i = 0; i < length; i++)
813  {
814  saveData(os, myPrimrenames(i).frompr);
815  saveData(os, myPrimrenames(i).topr);
816 
817  }
818  }
819  saveData(os, myPrimdel);
820  saveData(os, myPrimkeep);
821  {
822  int64 length = myDetailrenames.entries();
823  UTwrite(os, &length);
824  for (exint i = 0; i < length; i++)
825  {
826  saveData(os, myDetailrenames(i).fromdtl);
827  saveData(os, myDetailrenames(i).todtl);
828 
829  }
830  }
831  saveData(os, myDtldel);
832  saveData(os, myDtlkeep);
833  {
834  int64 length = myRmanconversions.entries();
835  UTwrite(os, &length);
836  for (exint i = 0; i < length; i++)
837  {
838  saveData(os, myRmanconversions(i).hname);
839  saveData(os, myRmanconversions(i).riname);
840  saveData(os, myRmanconversions(i).ritype);
841  saveData(os, myRmanconversions(i).rioff);
842 
843  }
844  }
845  saveData(os, myRidefault);
846  saveData(os, myUpdatevar);
847  saveData(os, myOverwrite);
848 
849  }
850 
851  bool load(UT_IStream &is)
852  {
853  int32 v;
854  is.bread(&v, 1);
855  if (version() != v)
856  {
857  // Fail incompatible versions
858  return false;
859  }
860  {
861  int64 length;
862  is.read(&length, 1);
863  myPtrenames.entries(length);
864  for (exint i = 0; i < length; i++)
865  {
866  loadData(is, myPtrenames(i).frompt);
867  loadData(is, myPtrenames(i).topt);
868 
869  }
870  }
871  loadData(is, myPtdel);
872  loadData(is, myPtkeep);
873  {
874  int64 length;
875  is.read(&length, 1);
876  myVtxrenames.entries(length);
877  for (exint i = 0; i < length; i++)
878  {
879  loadData(is, myVtxrenames(i).fromvtx);
880  loadData(is, myVtxrenames(i).tovtx);
881 
882  }
883  }
884  loadData(is, myVtxdel);
885  loadData(is, myVtxkeep);
886  {
887  int64 length;
888  is.read(&length, 1);
889  myPrimrenames.entries(length);
890  for (exint i = 0; i < length; i++)
891  {
892  loadData(is, myPrimrenames(i).frompr);
893  loadData(is, myPrimrenames(i).topr);
894 
895  }
896  }
897  loadData(is, myPrimdel);
898  loadData(is, myPrimkeep);
899  {
900  int64 length;
901  is.read(&length, 1);
902  myDetailrenames.entries(length);
903  for (exint i = 0; i < length; i++)
904  {
905  loadData(is, myDetailrenames(i).fromdtl);
906  loadData(is, myDetailrenames(i).todtl);
907 
908  }
909  }
910  loadData(is, myDtldel);
911  loadData(is, myDtlkeep);
912  {
913  int64 length;
914  is.read(&length, 1);
915  myRmanconversions.entries(length);
916  for (exint i = 0; i < length; i++)
917  {
918  loadData(is, myRmanconversions(i).hname);
919  loadData(is, myRmanconversions(i).riname);
920  loadData(is, myRmanconversions(i).ritype);
921  loadData(is, myRmanconversions(i).rioff);
922 
923  }
924  }
925  loadData(is, myRidefault);
926  loadData(is, myUpdatevar);
927  loadData(is, myOverwrite);
928 
929  return true;
930  }
931 
932  const UT_Array<Ptrenames> &getPtrenames() const { return myPtrenames; }
933  void setPtrenames(const UT_Array<Ptrenames> &val) { myPtrenames = val; }
934  exint opPtrenames(const SOP_NodeVerb::CookParms &cookparms) const
935  {
936  SOP_Node *thissop = cookparms.getNode();
937  if (!thissop) return getPtrenames().entries();
938  exint result;
939  OP_Utils::evalOpParm(result, thissop, "ptrenames", cookparms.getCookTime(), 0);
940  return result;
941  }
943  {
944  SOP_Node *thissop = cookparms.getNode();
945  if (!thissop) return (myPtrenames(_idx).frompt);
946  int _parmidx = _idx + 0;
947  UT_StringHolder result;
948  OP_Utils::evalOpParmInst(result, thissop, "frompt#", &_parmidx, cookparms.getCookTime(), 0);
949  return (result);
950  }
952  {
953  SOP_Node *thissop = cookparms.getNode();
954  if (!thissop) return (myPtrenames(_idx).topt);
955  int _parmidx = _idx + 0;
956  UT_StringHolder result;
957  OP_Utils::evalOpParmInst(result, thissop, "topt#", &_parmidx, cookparms.getCookTime(), 0);
958  return (result);
959  }
960 
961  const UT_StringHolder & getPtdel() const { return myPtdel; }
962  void setPtdel(const UT_StringHolder & val) { myPtdel = val; }
964  {
965  SOP_Node *thissop = cookparms.getNode();
966  if (!thissop) return getPtdel();
967  UT_StringHolder result;
968  OP_Utils::evalOpParm(result, thissop, "ptdel", cookparms.getCookTime(), 0);
969  return result;
970  }
971  const UT_StringHolder & getPtkeep() const { return myPtkeep; }
972  void setPtkeep(const UT_StringHolder & val) { myPtkeep = val; }
974  {
975  SOP_Node *thissop = cookparms.getNode();
976  if (!thissop) return getPtkeep();
977  UT_StringHolder result;
978  OP_Utils::evalOpParm(result, thissop, "ptkeep", cookparms.getCookTime(), 0);
979  return result;
980  }
981  const UT_Array<Vtxrenames> &getVtxrenames() const { return myVtxrenames; }
982  void setVtxrenames(const UT_Array<Vtxrenames> &val) { myVtxrenames = val; }
984  {
985  SOP_Node *thissop = cookparms.getNode();
986  if (!thissop) return getVtxrenames().entries();
987  exint result;
988  OP_Utils::evalOpParm(result, thissop, "vtxrenames", cookparms.getCookTime(), 0);
989  return result;
990  }
992  {
993  SOP_Node *thissop = cookparms.getNode();
994  if (!thissop) return (myVtxrenames(_idx).fromvtx);
995  int _parmidx = _idx + 0;
996  UT_StringHolder result;
997  OP_Utils::evalOpParmInst(result, thissop, "fromvtx#", &_parmidx, cookparms.getCookTime(), 0);
998  return (result);
999  }
1001  {
1002  SOP_Node *thissop = cookparms.getNode();
1003  if (!thissop) return (myVtxrenames(_idx).tovtx);
1004  int _parmidx = _idx + 0;
1005  UT_StringHolder result;
1006  OP_Utils::evalOpParmInst(result, thissop, "tovtx#", &_parmidx, cookparms.getCookTime(), 0);
1007  return (result);
1008  }
1009 
1010  const UT_StringHolder & getVtxdel() const { return myVtxdel; }
1011  void setVtxdel(const UT_StringHolder & val) { myVtxdel = val; }
1013  {
1014  SOP_Node *thissop = cookparms.getNode();
1015  if (!thissop) return getVtxdel();
1016  UT_StringHolder result;
1017  OP_Utils::evalOpParm(result, thissop, "vtxdel", cookparms.getCookTime(), 0);
1018  return result;
1019  }
1020  const UT_StringHolder & getVtxkeep() const { return myVtxkeep; }
1021  void setVtxkeep(const UT_StringHolder & val) { myVtxkeep = val; }
1023  {
1024  SOP_Node *thissop = cookparms.getNode();
1025  if (!thissop) return getVtxkeep();
1026  UT_StringHolder result;
1027  OP_Utils::evalOpParm(result, thissop, "vtxkeep", cookparms.getCookTime(), 0);
1028  return result;
1029  }
1030  const UT_Array<Primrenames> &getPrimrenames() const { return myPrimrenames; }
1031  void setPrimrenames(const UT_Array<Primrenames> &val) { myPrimrenames = val; }
1033  {
1034  SOP_Node *thissop = cookparms.getNode();
1035  if (!thissop) return getPrimrenames().entries();
1036  exint result;
1037  OP_Utils::evalOpParm(result, thissop, "primrenames", cookparms.getCookTime(), 0);
1038  return result;
1039  }
1041  {
1042  SOP_Node *thissop = cookparms.getNode();
1043  if (!thissop) return (myPrimrenames(_idx).frompr);
1044  int _parmidx = _idx + 0;
1045  UT_StringHolder result;
1046  OP_Utils::evalOpParmInst(result, thissop, "frompr#", &_parmidx, cookparms.getCookTime(), 0);
1047  return (result);
1048  }
1050  {
1051  SOP_Node *thissop = cookparms.getNode();
1052  if (!thissop) return (myPrimrenames(_idx).topr);
1053  int _parmidx = _idx + 0;
1054  UT_StringHolder result;
1055  OP_Utils::evalOpParmInst(result, thissop, "topr#", &_parmidx, cookparms.getCookTime(), 0);
1056  return (result);
1057  }
1058 
1059  const UT_StringHolder & getPrimdel() const { return myPrimdel; }
1060  void setPrimdel(const UT_StringHolder & val) { myPrimdel = val; }
1062  {
1063  SOP_Node *thissop = cookparms.getNode();
1064  if (!thissop) return getPrimdel();
1065  UT_StringHolder result;
1066  OP_Utils::evalOpParm(result, thissop, "primdel", cookparms.getCookTime(), 0);
1067  return result;
1068  }
1069  const UT_StringHolder & getPrimkeep() const { return myPrimkeep; }
1070  void setPrimkeep(const UT_StringHolder & val) { myPrimkeep = val; }
1072  {
1073  SOP_Node *thissop = cookparms.getNode();
1074  if (!thissop) return getPrimkeep();
1075  UT_StringHolder result;
1076  OP_Utils::evalOpParm(result, thissop, "primkeep", cookparms.getCookTime(), 0);
1077  return result;
1078  }
1079  const UT_Array<Detailrenames> &getDetailrenames() const { return myDetailrenames; }
1080  void setDetailrenames(const UT_Array<Detailrenames> &val) { myDetailrenames = val; }
1082  {
1083  SOP_Node *thissop = cookparms.getNode();
1084  if (!thissop) return getDetailrenames().entries();
1085  exint result;
1086  OP_Utils::evalOpParm(result, thissop, "detailrenames", cookparms.getCookTime(), 0);
1087  return result;
1088  }
1090  {
1091  SOP_Node *thissop = cookparms.getNode();
1092  if (!thissop) return (myDetailrenames(_idx).fromdtl);
1093  int _parmidx = _idx + 0;
1094  UT_StringHolder result;
1095  OP_Utils::evalOpParmInst(result, thissop, "fromdtl#", &_parmidx, cookparms.getCookTime(), 0);
1096  return (result);
1097  }
1099  {
1100  SOP_Node *thissop = cookparms.getNode();
1101  if (!thissop) return (myDetailrenames(_idx).todtl);
1102  int _parmidx = _idx + 0;
1103  UT_StringHolder result;
1104  OP_Utils::evalOpParmInst(result, thissop, "todtl#", &_parmidx, cookparms.getCookTime(), 0);
1105  return (result);
1106  }
1107 
1108  const UT_StringHolder & getDtldel() const { return myDtldel; }
1109  void setDtldel(const UT_StringHolder & val) { myDtldel = val; }
1111  {
1112  SOP_Node *thissop = cookparms.getNode();
1113  if (!thissop) return getDtldel();
1114  UT_StringHolder result;
1115  OP_Utils::evalOpParm(result, thissop, "dtldel", cookparms.getCookTime(), 0);
1116  return result;
1117  }
1118  const UT_StringHolder & getDtlkeep() const { return myDtlkeep; }
1119  void setDtlkeep(const UT_StringHolder & val) { myDtlkeep = val; }
1121  {
1122  SOP_Node *thissop = cookparms.getNode();
1123  if (!thissop) return getDtlkeep();
1124  UT_StringHolder result;
1125  OP_Utils::evalOpParm(result, thissop, "dtlkeep", cookparms.getCookTime(), 0);
1126  return result;
1127  }
1128  const UT_Array<Rmanconversions> &getRmanconversions() const { return myRmanconversions; }
1129  void setRmanconversions(const UT_Array<Rmanconversions> &val) { myRmanconversions = val; }
1131  {
1132  SOP_Node *thissop = cookparms.getNode();
1133  if (!thissop) return getRmanconversions().entries();
1134  exint result;
1135  OP_Utils::evalOpParm(result, thissop, "rmanconversions", cookparms.getCookTime(), 0);
1136  return result;
1137  }
1139  {
1140  SOP_Node *thissop = cookparms.getNode();
1141  if (!thissop) return (myRmanconversions(_idx).hname);
1142  int _parmidx = _idx + 0;
1143  UT_StringHolder result;
1144  OP_Utils::evalOpParmInst(result, thissop, "hname#", &_parmidx, cookparms.getCookTime(), 0);
1145  return (result);
1146  }
1148  {
1149  SOP_Node *thissop = cookparms.getNode();
1150  if (!thissop) return (myRmanconversions(_idx).riname);
1151  int _parmidx = _idx + 0;
1152  UT_StringHolder result;
1153  OP_Utils::evalOpParmInst(result, thissop, "riname#", &_parmidx, cookparms.getCookTime(), 0);
1154  return (result);
1155  }
1157  {
1158  SOP_Node *thissop = cookparms.getNode();
1159  if (!thissop) return (myRmanconversions(_idx).ritype);
1160  int _parmidx = _idx + 0;
1161  UT_StringHolder result;
1162  OP_Utils::evalOpParmInst(result, thissop, "ritype#", &_parmidx, cookparms.getCookTime(), 0);
1163  return (result);
1164  }
1166  {
1167  SOP_Node *thissop = cookparms.getNode();
1168  if (!thissop) return (myRmanconversions(_idx).rioff);
1169  int _parmidx = _idx + 0;
1170  int64 result;
1171  OP_Utils::evalOpParmInst(result, thissop, "rioff#", &_parmidx, cookparms.getCookTime(), 0);
1172  return (result);
1173  }
1174 
1175  bool getRidefault() const { return myRidefault; }
1176  void setRidefault(bool val) { myRidefault = val; }
1177  bool opRidefault(const SOP_NodeVerb::CookParms &cookparms) const
1178  {
1179  SOP_Node *thissop = cookparms.getNode();
1180  if (!thissop) return getRidefault();
1181  bool result;
1182  OP_Utils::evalOpParm(result, thissop, "ridefault", cookparms.getCookTime(), 0);
1183  return result;
1184  }
1185  bool getUpdatevar() const { return myUpdatevar; }
1186  void setUpdatevar(bool val) { myUpdatevar = val; }
1187  bool opUpdatevar(const SOP_NodeVerb::CookParms &cookparms) const
1188  {
1189  SOP_Node *thissop = cookparms.getNode();
1190  if (!thissop) return getUpdatevar();
1191  bool result;
1192  OP_Utils::evalOpParm(result, thissop, "updatevar", cookparms.getCookTime(), 0);
1193  return result;
1194  }
1195  bool getOverwrite() const { return myOverwrite; }
1196  void setOverwrite(bool val) { myOverwrite = val; }
1197  bool opOverwrite(const SOP_NodeVerb::CookParms &cookparms) const
1198  {
1199  SOP_Node *thissop = cookparms.getNode();
1200  if (!thissop) return getOverwrite();
1201  bool result;
1202  OP_Utils::evalOpParm(result, thissop, "overwrite", cookparms.getCookTime(), 0);
1203  return result;
1204  }
1205 
1206 private:
1207  UT_Array<Ptrenames> myPtrenames;
1208  UT_StringHolder myPtdel;
1209  UT_StringHolder myPtkeep;
1210  UT_Array<Vtxrenames> myVtxrenames;
1211  UT_StringHolder myVtxdel;
1212  UT_StringHolder myVtxkeep;
1213  UT_Array<Primrenames> myPrimrenames;
1214  UT_StringHolder myPrimdel;
1215  UT_StringHolder myPrimkeep;
1216  UT_Array<Detailrenames> myDetailrenames;
1217  UT_StringHolder myDtldel;
1218  UT_StringHolder myDtlkeep;
1219  UT_Array<Rmanconversions> myRmanconversions;
1220  bool myRidefault;
1221  bool myUpdatevar;
1222  bool myOverwrite;
1223 
1224 };
void getParmValue(exint idx, UT_Vector3D &value) const
void setDetailrenames(const UT_Array< Detailrenames > &val)
exint opRmanconversions(const SOP_NodeVerb::CookParms &cookparms) const
void setPrimrenames(const UT_Array< Primrenames > &val)
void setUpdatevar(bool val)
UT_StringHolder opDtlkeep(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder createString(const UT_Array< Ptrenames > &list) const
void setParmValue(exint idx, const UT_StringHolder &value)
static void loadData(UT_IStream &is, UT_Vector4D &v)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
const UT_StringHolder & getVtxkeep() const
T & z(void)
Definition: UT_Vector4.h:372
UT_StringHolder opVtxrenames_fromvtx(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void setPtrenames(const UT_Array< Ptrenames > &val)
bool opOverwrite(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opRmanconversions_ritype(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
virtual void loadFromOpSubclass(const LoadParms &loadparms)
virtual const char * getParmName(exint fieldnum) const
UT_StringHolder opVtxrenames_tovtx(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
exint bread(int32 *buffer, exint asize=1)
static void loadData(UT_IStream &is, UT_Vector4I &v)
fpreal getTime() const
Definition: OP_Context.h:34
const GLdouble * v
Definition: glcorearb.h:836
UT_StringHolder createString(const UT_Array< Vtxrenames > &list) const
UT_StringHolder opPtrenames_frompt(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
static void saveData(std::ostream &os, bool v)
UT_StringHolder createString(const UT_Array< Detailrenames > &list) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
static void saveData(std::ostream &os, UT_Vector3D v)
UT_StringHolder opRmanconversions_riname(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
UT_String makeQuotedString(char delimiter='\'', bool escape_nonprinting=false) const
static void saveData(std::ostream &os, UT_StringHolder s)
void setParmValue(exint idx, const UT_Vector3D &value)
UT_StringHolder opPtdel(const SOP_NodeVerb::CookParms &cookparms) const
T & x(void)
Definition: UT_Vector2.h:284
UT_StringHolder opVtxkeep(const SOP_NodeVerb::CookParms &cookparms) const
const UT_Array< Detailrenames > & getDetailrenames() const
An output stream object that owns its own string buffer storage.
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void getParmValue(exint idx, UT_StringHolder &value) const
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
static void saveData(std::ostream &os, UT_Matrix4D v)
UT_StringHolder opPrimdel(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getPrimdel() const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
png_uint_32 i
Definition: png.h:2877
static void loadData(UT_IStream &is, UT_Vector3I &v)
static void loadData(UT_IStream &is, bool &v)
const UT_Array< Primrenames > & getPrimrenames() const
void setParmValue(exint idx, const UT_Matrix4D &value)
void setPtdel(const UT_StringHolder &val)
UT_StringHolder opDetailrenames_fromdtl(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
const UT_Array< Ptrenames > & getPtrenames() const
void doSetParmValue(exint idx, const T &value)
void setPrimkeep(const UT_StringHolder &val)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
void setParmValue(exint idx, const UT_Vector2D &value)
long long int64
Definition: SYS_Types.h:106
UT_StringHolder opPtrenames_topt(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
UT_StringHolder opPtkeep(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getPtkeep() const
UT_StringHolder opRmanconversions_hname(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
void append(char character)
void doGetParmValue(exint idx, T &value) const
SYS_FORCE_INLINE const char * buffer() const
static void saveData(std::ostream &os, UT_Vector4D v)
int64 exint
Definition: SYS_Types.h:115
void setParmValue(exint idx, const UT_Matrix3D &value)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void loadData(UT_IStream &is, fpreal64 &v)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
UT_StringHolder opDtldel(const SOP_NodeVerb::CookParms &cookparms) const
double fpreal64
Definition: SYS_Types.h:191
bool operator==(const Detailrenames &src) const
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:280
virtual ParmType getParmType(exint fieldnum) const
UT_StringHolder opPrimrenames_frompr(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
const UT_StringHolder & getPrimkeep() const
void setParmValue(exint idx, const PRM_DataItemHandle &value)
void setParmValue(exint idx, const UT_Vector4D &value)
const UT_StringHolder & getDtldel() const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
static void loadData(UT_IStream &is, UT_Vector2I &v)
void save(std::ostream &os) const
UT_StringHolder createString(const UT_Array< Rmanconversions > &list) const
GLboolean * data
Definition: glcorearb.h:130
int int32
Definition: SYS_Types.h:34
UT_StringHolder opVtxdel(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix2D v)
T & y(void)
Definition: UT_Vector4.h:370
void setOverwrite(bool val)
UT_StringHolder opDetailrenames_todtl(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
exint opPtrenames(const SOP_NodeVerb::CookParms &cookparms) const
const UT_Array< Rmanconversions > & getRmanconversions() const
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
int64 opRmanconversions_rioff(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2539
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:446
exint opPrimrenames(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix3D v)
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_Array< Vtxrenames > & getVtxrenames() const
UT_StringHolder createString(const UT_Array< Primrenames > &list) const
void getParmValue(exint idx, UT_Matrix2D &value) const
void setParmValue(exint idx, const exint &value)
bool operator==(const SOP_AttributeParms &src) const
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:269
void strncpy(const char *src, exint maxlen)
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
void setRidefault(bool val)
static void saveData(std::ostream &os, int64 v)
void getParmValue(exint idx, UT_Matrix4D &value) const
static void loadData(UT_IStream &is, int64 &v)
const UT_StringHolder & getDtlkeep() const
UT_StringHolder opPrimkeep(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector4D &value) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void setVtxkeep(const UT_StringHolder &val)
void getParmValue(exint idx, UT_Matrix3D &value) const
void setVtxrenames(const UT_Array< Vtxrenames > &val)
bool operator==(const Ptrenames &src) const
const UT_StringHolder & getPtdel() const
UT_StringHolder opPrimrenames_topr(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void getParmValue(exint idx, fpreal &value) const
GLuint GLfloat * val
Definition: glcorearb.h:1607
void setParmValue(exint idx, const UT_Matrix2D &value)
bool operator==(const Rmanconversions &src) const
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
#define SOP_API
Definition: SOP_API.h:10
void setPtkeep(const UT_StringHolder &val)
void getParmValue(exint idx, UT_Vector2D &value) const
const char * buffer() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
static void loadData(UT_IStream &is, UT_Matrix3D &v)
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
const UT_StringHolder & getVtxdel() const
T & x(void)
Definition: UT_Vector4.h:368
exint opDetailrenames(const SOP_NodeVerb::CookParms &cookparms) const
bool opUpdatevar(const SOP_NodeVerb::CookParms &cookparms) const
void setVtxdel(const UT_StringHolder &val)
T & y(void)
Definition: UT_Vector2.h:286
exint opVtxrenames(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setPrimdel(const UT_StringHolder &val)
virtual exint getNumParms() const
GLboolean r
Definition: glcorearb.h:1221
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
static void loadData(UT_IStream &is, UT_StringHolder &v)
void setDtldel(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector3D &v)
bool operator==(const Primrenames &src) const
void strcat(const char *src)
T & w(void)
Definition: UT_Vector4.h:374
static void saveData(std::ostream &os, fpreal64 v)
void getParmValue(exint idx, exint &value) const
bool operator==(const Vtxrenames &src) const
bool opRidefault(const SOP_NodeVerb::CookParms &cookparms) const
void setDtlkeep(const UT_StringHolder &val)
void setParmValue(exint idx, const fpreal &value)
bool load(UT_IStream &is)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
virtual void copyFrom(const SOP_NodeParms *src)
SYS_FORCE_INLINE bool isstring() const
void setRmanconversions(const UT_Array< Rmanconversions > &val)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
GLenum src
Definition: glcorearb.h:1792
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)