HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Name.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 namespace SOP_NameEnums
22 {
23  enum class Class
24  {
25  PRIMITIVE = 0,
26  POINT
27  };
28 }
29 
30 
32 {
33 public:
34  static int version() { return 1; }
35  struct Numnames
36  {
39 
40 
42  {
43  group = ""_sh;
44  name = ""_sh;
45 
46  }
47 
48  bool operator==(const Numnames &src) const
49  {
50  if (group != src.group) return false;
51  if (name != src.name) return false;
52 
53  return true;
54  }
55  bool operator!=(const Numnames &src) const
56  {
57  return !operator==(src);
58  }
59 
60  };
61 
63  {
65 
66  buf.strcat("[ ");
67  for (int i = 0; i < list.entries(); i++)
68  {
69  if (i)
70  buf.strcat(", ");
71  buf.strcat("( ");
72  buf.append("");
73  { UT_String tmp; tmp = UT_StringWrap(list(i).group).makeQuotedString('"'); buf.strcat(tmp); }
74  buf.append(", ");
75  { UT_String tmp; tmp = UT_StringWrap(list(i).name).makeQuotedString('"'); buf.strcat(tmp); }
76 
77  buf.strcat(" )");
78  }
79  buf.strcat(" ]");
80 
81  UT_StringHolder result = buf;
82  return result;
83  }
84  struct Numrenames
85  {
86  bool enable;
87  bool global;
90 
91 
93  {
94  enable = false;
95  global = false;
96  from = ""_sh;
97  to = ""_sh;
98 
99  }
100 
101  bool operator==(const Numrenames &src) const
102  {
103  if (enable != src.enable) return false;
104  if (global != src.global) return false;
105  if (from != src.from) return false;
106  if (to != src.to) return false;
107 
108  return true;
109  }
110  bool operator!=(const Numrenames &src) const
111  {
112  return !operator==(src);
113  }
114 
115  };
116 
118  {
120 
121  buf.strcat("[ ");
122  for (int i = 0; i < list.entries(); i++)
123  {
124  if (i)
125  buf.strcat(", ");
126  buf.strcat("( ");
127  buf.append("");
128  buf.appendSprintf("%s", (list(i).enable) ? "true" : "false");
129  buf.append(", ");
130  buf.appendSprintf("%s", (list(i).global) ? "true" : "false");
131  buf.append(", ");
132  { UT_String tmp; tmp = UT_StringWrap(list(i).from).makeQuotedString('"'); buf.strcat(tmp); }
133  buf.append(", ");
134  { UT_String tmp; tmp = UT_StringWrap(list(i).to).makeQuotedString('"'); buf.strcat(tmp); }
135 
136  buf.strcat(" )");
137  }
138  buf.strcat(" ]");
139 
140  UT_StringHolder result = buf;
141  return result;
142  }
143 
145  {
146  myAttribname = "name"_sh;
147  myClass = 0;
148  myDonamefromgroup = false;
149  myNamefromgroupmask = "piece*"_sh;
150 
151  }
152 
153  explicit SOP_NameParms(const SOP_NameParms &) = default;
154 
155  virtual ~SOP_NameParms() {}
156 
157  bool operator==(const SOP_NameParms &src) const
158  {
159  if (myAttribname != src.myAttribname) return false;
160  if (myClass != src.myClass) return false;
161  if (myDonamefromgroup != src.myDonamefromgroup) return false;
162  if (myNamefromgroupmask != src.myNamefromgroupmask) return false;
163  if (myNumnames != src.myNumnames) return false;
164  if (myNumrenames != src.myNumrenames) return false;
165 
166  return true;
167  }
168  bool operator!=(const SOP_NameParms &src) const
169  {
170  return !operator==(src);
171  }
173 
174 
175 
176  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
177  {
178  if (true)
179  OP_Utils::evalOpParm(myAttribname, node, "attribname", time, 0);
180  else myAttribname = "name"_sh;
181  if (true)
182  OP_Utils::evalOpParm(myClass, node, "class", time, 0);
183  else myClass = 0;
184  if (true)
185  OP_Utils::evalOpParm(myDonamefromgroup, node, "donamefromgroup", time, 0);
186  else myDonamefromgroup = false;
187  if (true && ( (!(((getDonamefromgroup()==0)))) ) )
188  OP_Utils::evalOpParm(myNamefromgroupmask, node, "namefromgroupmask", time, 0);
189  else myNamefromgroupmask = "piece*"_sh;
190  if (true)
191  {
192  int64 length;
193  OP_Utils::evalOpParm(length, node, "numnames", time, 0);
194  myNumnames.entries(length);
195  for (exint i = 0; i < length; i++)
196  {
197  int parmidx = i+1;
198  auto && _curentry = myNumnames(i);
199  (void) _curentry;
200  if (true)
201  OP_Utils::evalOpParmInst(myNumnames(i).group, node, "group#", &parmidx, time, 0);
202  else myNumnames(i).group = ""_sh;
203  if (true)
204  OP_Utils::evalOpParmInst(myNumnames(i).name, node, "name#", &parmidx, time, 0);
205  else myNumnames(i).name = ""_sh;
206 
207  }
208  }
209  else
210  myNumnames.clear();
211  if (true)
212  {
213  int64 length;
214  OP_Utils::evalOpParm(length, node, "numrenames", time, 0);
215  myNumrenames.entries(length);
216  for (exint i = 0; i < length; i++)
217  {
218  int parmidx = i+1;
219  auto && _curentry = myNumrenames(i);
220  (void) _curentry;
221  if (true)
222  OP_Utils::evalOpParmInst(myNumrenames(i).enable, node, "enable#", &parmidx, time, 0);
223  else myNumrenames(i).enable = false;
224  if (true && ( (!(((_curentry.enable==0)))) ) )
225  OP_Utils::evalOpParmInst(myNumrenames(i).global, node, "global#", &parmidx, time, 0);
226  else myNumrenames(i).global = false;
227  if (true && ( (!(((_curentry.enable==0)))) ) )
228  OP_Utils::evalOpParmInst(myNumrenames(i).from, node, "from#", &parmidx, time, 0);
229  else myNumrenames(i).from = ""_sh;
230  if (true && ( (!(((_curentry.enable==0)))) ) )
231  OP_Utils::evalOpParmInst(myNumrenames(i).to, node, "to#", &parmidx, time, 0);
232  else myNumrenames(i).to = ""_sh;
233 
234  }
235  }
236  else
237  myNumrenames.clear();
238 
239  }
240 
241 
242  virtual void loadFromOpSubclass(const LoadParms &loadparms)
243  {
244  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
245  }
246 
247 
248  virtual void copyFrom(const SOP_NodeParms *src)
249  {
250  *this = *((const SOP_NameParms *)src);
251  }
252 
253  template <typename T>
254  void
255  doGetParmValue(exint idx, T &value) const
256  {
257  switch (idx)
258  {
259  case 0:
260  coerceValue(value, myAttribname);
261  break;
262  case 1:
263  coerceValue(value, myClass);
264  break;
265  case 2:
266  coerceValue(value, myDonamefromgroup);
267  break;
268  case 3:
269  coerceValue(value, myNamefromgroupmask);
270  break;
271 
272  }
273  }
274 
275  void getParmValue(exint idx, exint &value) const
276  { doGetParmValue(idx, value); }
277  void getParmValue(exint idx, fpreal &value) const
278  { doGetParmValue(idx, value); }
280  { doGetParmValue(idx, value); }
282  { doGetParmValue(idx, value); }
284  { doGetParmValue(idx, value); }
286  { doGetParmValue(idx, value); }
288  { doGetParmValue(idx, value); }
290  { doGetParmValue(idx, value); }
292  { doGetParmValue(idx, value); }
294  { doGetParmValue(idx, value); }
296  { doGetParmValue(idx, value); }
297 
298  template <typename T>
299  void
300  doSetParmValue(exint idx, const T &value)
301  {
302  switch (idx)
303  {
304  case 0:
305  coerceValue(myAttribname, value);
306  break;
307  case 1:
308  coerceValue(myClass, value);
309  break;
310  case 2:
311  coerceValue(myDonamefromgroup, value);
312  break;
313  case 3:
314  coerceValue(myNamefromgroupmask, value);
315  break;
316 
317  }
318  }
319 
320  void setParmValue(exint idx, const exint &value)
321  { doSetParmValue(idx, value); }
322  void setParmValue(exint idx, const fpreal &value)
323  { doSetParmValue(idx, value); }
324  void setParmValue(exint idx, const UT_Vector2D &value)
325  { doSetParmValue(idx, value); }
326  void setParmValue(exint idx, const UT_Vector3D &value)
327  { doSetParmValue(idx, value); }
328  void setParmValue(exint idx, const UT_Vector4D &value)
329  { doSetParmValue(idx, value); }
330  void setParmValue(exint idx, const UT_Matrix2D &value)
331  { doSetParmValue(idx, value); }
332  void setParmValue(exint idx, const UT_Matrix3D &value)
333  { doSetParmValue(idx, value); }
334  void setParmValue(exint idx, const UT_Matrix4D &value)
335  { doSetParmValue(idx, value); }
337  { doSetParmValue(idx, value); }
339  { doSetParmValue(idx, value); }
341  { doSetParmValue(idx, value); }
342 
343  virtual exint getNumParms() const
344  {
345  return 6;
346  }
347 
348  virtual const char *getParmName(exint fieldnum) const
349  {
350  switch (fieldnum)
351  {
352  case 0:
353  return "attribname";
354  case 1:
355  return "class";
356  case 2:
357  return "donamefromgroup";
358  case 3:
359  return "namefromgroupmask";
360  case 4:
361  return "numnames";
362  case 5:
363  return "numrenames";
364 
365  }
366  return 0;
367  }
368 
369  virtual ParmType getParmType(exint fieldnum) const
370  {
371  switch (fieldnum)
372  {
373  case 0:
374  return PARM_STRING;
375  case 1:
376  return PARM_INTEGER;
377  case 2:
378  return PARM_INTEGER;
379  case 3:
380  return PARM_STRING;
381 
382  }
383  return PARM_UNSUPPORTED;
384  }
385 
386  // Boiler plate to load individual types.
387  static void loadData(UT_IStream &is, int64 &v)
388  { is.bread(&v, 1); }
389  static void loadData(UT_IStream &is, bool &v)
390  { int64 iv; is.bread(&iv, 1); v = iv; }
391  static void loadData(UT_IStream &is, fpreal64 &v)
392  { is.bread<fpreal64>(&v, 1); }
393  static void loadData(UT_IStream &is, UT_Vector2D &v)
394  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
395  static void loadData(UT_IStream &is, UT_Vector3D &v)
396  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
397  is.bread<fpreal64>(&v.z(), 1); }
398  static void loadData(UT_IStream &is, UT_Vector4D &v)
399  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
400  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
401  static void loadData(UT_IStream &is, UT_Matrix2D &v)
402  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
403  static void loadData(UT_IStream &is, UT_Matrix3D &v)
404  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
405  static void loadData(UT_IStream &is, UT_Matrix4D &v)
406  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
407  static void loadData(UT_IStream &is, UT_Vector2I &v)
408  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
409  static void loadData(UT_IStream &is, UT_Vector3I &v)
410  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
411  is.bread<int64>(&v.z(), 1); }
412  static void loadData(UT_IStream &is, UT_Vector4I &v)
413  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
414  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
416  { is.bread(v); }
418  { UT_StringHolder rampdata;
419  loadData(is, rampdata);
420  if (rampdata.isstring())
421  {
422  v.reset(new UT_Ramp());
423  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
424  v->load(istr);
425  }
426  else v.reset();
427  }
430  loadData(is, data);
431  if (data.isstring())
432  {
433  // Find the data type.
434  char *colon = UT_StringWrap(data).findChar(':');
435  if (colon)
436  {
437  int typelen = colon - data.buffer();
439  type.strncpy(data.buffer(), typelen);
440  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
441 
442  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
443  }
444  }
445  else v.reset();
446  }
447 
448  static void saveData(std::ostream &os, int64 v)
449  { UTwrite(os, &v); }
450  static void saveData(std::ostream &os, bool v)
451  { int64 iv = v; UTwrite(os, &iv); }
452  static void saveData(std::ostream &os, fpreal64 v)
453  { UTwrite<fpreal64>(os, &v); }
454  static void saveData(std::ostream &os, UT_Vector2D v)
455  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
456  static void saveData(std::ostream &os, UT_Vector3D v)
457  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
458  UTwrite<fpreal64>(os, &v.z()); }
459  static void saveData(std::ostream &os, UT_Vector4D v)
460  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
461  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
462  static void saveData(std::ostream &os, UT_Matrix2D v)
464  static void saveData(std::ostream &os, UT_Matrix3D v)
466  static void saveData(std::ostream &os, UT_Matrix4D v)
468  static void saveData(std::ostream &os, UT_StringHolder s)
469  { UT_StringWrap(s).saveBinary(os); }
470  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
471  { UT_StringHolder result;
472  UT_OStringStream ostr;
473  if (s) s->save(ostr);
474  result = ostr.str();
475  saveData(os, result);
476  }
477  static void saveData(std::ostream &os, PRM_DataItemHandle s)
478  { UT_StringHolder result;
479  UT_OStringStream ostr;
480  if (s)
481  {
482  ostr << s->getDataTypeToken();
483  ostr << ":";
484  s->saveBinary(ostr);
485  }
486  result = ostr.str();
487  saveData(os, result);
488  }
489 
490 
491  void save(std::ostream &os) const
492  {
493  int32 v = version();
494  UTwrite(os, &v);
495  saveData(os, myAttribname);
496  saveData(os, myClass);
497  saveData(os, myDonamefromgroup);
498  saveData(os, myNamefromgroupmask);
499  {
500  int64 length = myNumnames.entries();
501  UTwrite(os, &length);
502  for (exint i = 0; i < length; i++)
503  {
504  saveData(os, myNumnames(i).group);
505  saveData(os, myNumnames(i).name);
506 
507  }
508  }
509  {
510  int64 length = myNumrenames.entries();
511  UTwrite(os, &length);
512  for (exint i = 0; i < length; i++)
513  {
514  saveData(os, myNumrenames(i).enable);
515  saveData(os, myNumrenames(i).global);
516  saveData(os, myNumrenames(i).from);
517  saveData(os, myNumrenames(i).to);
518 
519  }
520  }
521 
522  }
523 
524  bool load(UT_IStream &is)
525  {
526  int32 v;
527  is.bread(&v, 1);
528  if (version() != v)
529  {
530  // Fail incompatible versions
531  return false;
532  }
533  loadData(is, myAttribname);
534  loadData(is, myClass);
535  loadData(is, myDonamefromgroup);
536  loadData(is, myNamefromgroupmask);
537  {
538  int64 length;
539  is.read(&length, 1);
540  myNumnames.entries(length);
541  for (exint i = 0; i < length; i++)
542  {
543  loadData(is, myNumnames(i).group);
544  loadData(is, myNumnames(i).name);
545 
546  }
547  }
548  {
549  int64 length;
550  is.read(&length, 1);
551  myNumrenames.entries(length);
552  for (exint i = 0; i < length; i++)
553  {
554  loadData(is, myNumrenames(i).enable);
555  loadData(is, myNumrenames(i).global);
556  loadData(is, myNumrenames(i).from);
557  loadData(is, myNumrenames(i).to);
558 
559  }
560  }
561 
562  return true;
563  }
564 
565  const UT_StringHolder & getAttribname() const { return myAttribname; }
566  void setAttribname(const UT_StringHolder & val) { myAttribname = val; }
568  {
569  SOP_Node *thissop = cookparms.getNode();
570  if (!thissop) return getAttribname();
571  UT_StringHolder result;
572  OP_Utils::evalOpParm(result, thissop, "attribname", cookparms.getCookTime(), 0);
573  return result;
574  }
575  Class getClass() const { return Class(myClass); }
576  void setClass(Class val) { myClass = int64(val); }
577  Class opClass(const SOP_NodeVerb::CookParms &cookparms) const
578  {
579  SOP_Node *thissop = cookparms.getNode();
580  if (!thissop) return getClass();
581  int64 result;
582  OP_Utils::evalOpParm(result, thissop, "class", cookparms.getCookTime(), 0);
583  return Class(result);
584  }
585  bool getDonamefromgroup() const { return myDonamefromgroup; }
586  void setDonamefromgroup(bool val) { myDonamefromgroup = val; }
587  bool opDonamefromgroup(const SOP_NodeVerb::CookParms &cookparms) const
588  {
589  SOP_Node *thissop = cookparms.getNode();
590  if (!thissop) return getDonamefromgroup();
591  bool result;
592  OP_Utils::evalOpParm(result, thissop, "donamefromgroup", cookparms.getCookTime(), 0);
593  return result;
594  }
595  const UT_StringHolder & getNamefromgroupmask() const { return myNamefromgroupmask; }
596  void setNamefromgroupmask(const UT_StringHolder & val) { myNamefromgroupmask = val; }
598  {
599  SOP_Node *thissop = cookparms.getNode();
600  if (!thissop) return getNamefromgroupmask();
601  UT_StringHolder result;
602  OP_Utils::evalOpParm(result, thissop, "namefromgroupmask", cookparms.getCookTime(), 0);
603  return result;
604  }
605  const UT_Array<Numnames> &getNumnames() const { return myNumnames; }
606  void setNumnames(const UT_Array<Numnames> &val) { myNumnames = val; }
607  exint opNumnames(const SOP_NodeVerb::CookParms &cookparms) const
608  {
609  SOP_Node *thissop = cookparms.getNode();
610  if (!thissop) return getNumnames().entries();
611  exint result;
612  OP_Utils::evalOpParm(result, thissop, "numnames", cookparms.getCookTime(), 0);
613  return result;
614  }
616  {
617  SOP_Node *thissop = cookparms.getNode();
618  if (!thissop) return (myNumnames(_idx).group);
619  int _parmidx = _idx + 1;
620  UT_StringHolder result;
621  OP_Utils::evalOpParmInst(result, thissop, "group#", &_parmidx, cookparms.getCookTime(), 0);
622  return (result);
623  }
625  {
626  SOP_Node *thissop = cookparms.getNode();
627  if (!thissop) return (myNumnames(_idx).name);
628  int _parmidx = _idx + 1;
629  UT_StringHolder result;
630  OP_Utils::evalOpParmInst(result, thissop, "name#", &_parmidx, cookparms.getCookTime(), 0);
631  return (result);
632  }
633 
634  const UT_Array<Numrenames> &getNumrenames() const { return myNumrenames; }
635  void setNumrenames(const UT_Array<Numrenames> &val) { myNumrenames = val; }
637  {
638  SOP_Node *thissop = cookparms.getNode();
639  if (!thissop) return getNumrenames().entries();
640  exint result;
641  OP_Utils::evalOpParm(result, thissop, "numrenames", cookparms.getCookTime(), 0);
642  return result;
643  }
644  bool opNumrenames_enable(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
645  {
646  SOP_Node *thissop = cookparms.getNode();
647  if (!thissop) return (myNumrenames(_idx).enable);
648  int _parmidx = _idx + 1;
649  bool result;
650  OP_Utils::evalOpParmInst(result, thissop, "enable#", &_parmidx, cookparms.getCookTime(), 0);
651  return (result);
652  }
653  bool opNumrenames_global(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
654  {
655  SOP_Node *thissop = cookparms.getNode();
656  if (!thissop) return (myNumrenames(_idx).global);
657  int _parmidx = _idx + 1;
658  bool result;
659  OP_Utils::evalOpParmInst(result, thissop, "global#", &_parmidx, cookparms.getCookTime(), 0);
660  return (result);
661  }
663  {
664  SOP_Node *thissop = cookparms.getNode();
665  if (!thissop) return (myNumrenames(_idx).from);
666  int _parmidx = _idx + 1;
667  UT_StringHolder result;
668  OP_Utils::evalOpParmInst(result, thissop, "from#", &_parmidx, cookparms.getCookTime(), 0);
669  return (result);
670  }
672  {
673  SOP_Node *thissop = cookparms.getNode();
674  if (!thissop) return (myNumrenames(_idx).to);
675  int _parmidx = _idx + 1;
676  UT_StringHolder result;
677  OP_Utils::evalOpParmInst(result, thissop, "to#", &_parmidx, cookparms.getCookTime(), 0);
678  return (result);
679  }
680 
681 
682 private:
683  UT_StringHolder myAttribname;
684  int64 myClass;
685  bool myDonamefromgroup;
686  UT_StringHolder myNamefromgroupmask;
687  UT_Array<Numnames> myNumnames;
688  UT_Array<Numrenames> myNumrenames;
689 
690 };
static void loadData(UT_IStream &is, UT_Vector2I &v)
static void loadData(UT_IStream &is, UT_Vector3D &v)
virtual const char * getParmName(exint fieldnum) const
Class opClass(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const Numrenames &src) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
void getParmValue(exint idx, UT_Matrix4D &value) const
T & z(void)
Definition: UT_Vector4.h:379
bool operator==(const SOP_NameParms &src) const
static void saveData(std::ostream &os, UT_Vector3D v)
exint bread(int32 *buffer, exint asize=1)
static void saveData(std::ostream &os, UT_Vector4D v)
GT_API const UT_StringHolder time
UT_StringHolder opAttribname(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:60
const GLdouble * v
Definition: glcorearb.h:836
virtual void copyFrom(const SOP_NodeParms *src)
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
UT_StringHolder opNumnames_name(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void setDonamefromgroup(bool val)
UT_String makeQuotedString(char delimiter='\'', bool escape_nonprinting=false) const
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
An output stream object that owns its own string buffer storage.
bool opNumrenames_enable(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
UT_StringHolder createString(const UT_Array< Numnames > &list) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void saveData(std::ostream &os, int64 v)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
exint opNumnames(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder createString(const UT_Array< Numrenames > &list) const
static void loadData(UT_IStream &is, UT_Vector4D &v)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
static void loadData(UT_IStream &is, UT_Vector3I &v)
bool opDonamefromgroup(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
png_uint_32 i
Definition: png.h:2877
UT_StringHolder opNumrenames_from(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_StringHolder & getAttribname() const
static void saveData(std::ostream &os, UT_Matrix2D v)
bool getDonamefromgroup() const
UT_StringHolder opNamefromgroupmask(const SOP_NodeVerb::CookParms &cookparms) const
virtual ParmType getParmType(exint fieldnum) const
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
long long int64
Definition: SYS_Types.h:107
void setNamefromgroupmask(const UT_StringHolder &val)
bool operator!=(const Numnames &src) const
void getParmValue(exint idx, exint &value) const
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
void getParmValue(exint idx, UT_Matrix3D &value) const
exint length() const
bool opNumrenames_global(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
void doSetParmValue(exint idx, const T &value)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
UT_StringHolder opNumrenames_to(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
virtual void loadFromOpSubclass(const LoadParms &loadparms)
int64 exint
Definition: SYS_Types.h:116
void getParmValue(exint idx, UT_Vector4D &value) const
void setNumnames(const UT_Array< Numnames > &val)
void getParmValue(exint idx, UT_Vector2D &value) const
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
static void loadData(UT_IStream &is, fpreal64 &v)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
double fpreal64
Definition: SYS_Types.h:192
void setParmValue(exint idx, const UT_Matrix2D &value)
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:284
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
static void saveData(std::ostream &os, bool v)
void setParmValue(exint idx, const UT_Vector3D &value)
static void loadData(UT_IStream &is, int64 &v)
void setClass(Class val)
void setParmValue(exint idx, const UT_Vector2D &value)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void doGetParmValue(exint idx, T &value) const
void setParmValue(exint idx, const UT_StringHolder &value)
GLboolean * data
Definition: glcorearb.h:130
GLuint const GLchar * name
Definition: glcorearb.h:785
int int32
Definition: SYS_Types.h:35
void setParmValue(exint idx, const UT_Vector4D &value)
T & y(void)
Definition: UT_Vector4.h:377
const UT_Array< Numnames > & getNumnames() const
static void saveData(std::ostream &os, UT_Matrix4D v)
SYS_FORCE_INLINE void strcat(const char *src)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
static void loadData(UT_IStream &is, UT_StringHolder &v)
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2539
exint entries() const
Alias of size(). size() is preferred.
Definition: UT_Array.h:453
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
exint opNumrenames(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:500
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:270
void getParmValue(exint idx, fpreal &value) const
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
void setNumrenames(const UT_Array< Numrenames > &val)
void save(std::ostream &os) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
static int version()
Class getClass() const
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
virtual exint getNumParms() const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
UT_StringHolder name
const UT_StringHolder & getNamefromgroupmask() const
static void saveData(std::ostream &os, fpreal64 v)
SYS_FORCE_INLINE void append(char character)
static void saveData(std::ostream &os, UT_Matrix3D v)
GLuint GLfloat * val
Definition: glcorearb.h:1607
static void loadData(UT_IStream &is, bool &v)
#define SOP_API
Definition: SOP_API.h:10
bool operator!=(const Numrenames &src) const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setAttribname(const UT_StringHolder &val)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
T & x(void)
Definition: UT_Vector4.h:375
void getParmValue(exint idx, UT_StringHolder &value) const
void setParmValue(exint idx, const UT_Matrix4D &value)
bool operator==(const Numnames &src) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
UT_StringHolder opNumnames_group(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
T & y(void)
Definition: UT_Vector2.h:287
void setParmValue(exint idx, const fpreal &value)
void getParmValue(exint idx, UT_Matrix2D &value) const
void setParmValue(exint idx, const UT_Matrix3D &value)
GLboolean r
Definition: glcorearb.h:1221
void getParmValue(exint idx, UT_Vector3D &value) const
static void saveData(std::ostream &os, UT_StringHolder s)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
T & w(void)
Definition: UT_Vector4.h:381
static void saveData(std::ostream &os, PRM_DataItemHandle s)
virtual ~SOP_NameParms()
UT_StringHolder group
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
const UT_Array< Numrenames > & getNumrenames() const
bool operator!=(const SOP_NameParms &src) const
SYS_FORCE_INLINE bool isstring() const
void setParmValue(exint idx, const exint &value)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
GLenum src
Definition: glcorearb.h:1792