HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_GroupCombine.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_GroupCombineEnums
22 {
23  enum class Grouptype
24  {
25  GUESS = 0,
26  POINTS,
27  PRIMS,
28  EDGES
29  };
30  enum class Negate_a
31  {
32  OFF = 0,
33  ON
34  };
35  enum class Op_ab
36  {
37  NONE = 0,
38  OR,
39  AND,
40  XOR,
41  SUB
42  };
43  enum class Negate_b
44  {
45  OFF = 0,
46  ON
47  };
48  enum class Op_bc
49  {
50  NONE = 0,
51  OR,
52  AND,
53  XOR,
54  SUB
55  };
56  enum class Negate_c
57  {
58  OFF = 0,
59  ON
60  };
61  enum class Op_cd
62  {
63  NONE = 0,
64  OR,
65  AND,
66  XOR,
67  SUB
68  };
69  enum class Negate_d
70  {
71  OFF = 0,
72  ON
73  };
74 }
75 
76 
78 {
79 public:
80  static int version() { return 1; }
81  struct Numcombine
82  {
96 
97 
99  {
100  grouptype = 0;
101  group = ""_sh;
102  negate_a = 0;
103  group_a = ""_sh;
104  op_ab = 0;
105  negate_b = 0;
106  group_b = ""_sh;
107  op_bc = 0;
108  negate_c = 0;
109  group_c = ""_sh;
110  op_cd = 0;
111  negate_d = 0;
112  group_d = ""_sh;
113 
114  }
115 
116  bool operator==(const Numcombine &src) const
117  {
118  if (grouptype != src.grouptype) return false;
119  if (group != src.group) return false;
120  if (negate_a != src.negate_a) return false;
121  if (group_a != src.group_a) return false;
122  if (op_ab != src.op_ab) return false;
123  if (negate_b != src.negate_b) return false;
124  if (group_b != src.group_b) return false;
125  if (op_bc != src.op_bc) return false;
126  if (negate_c != src.negate_c) return false;
127  if (group_c != src.group_c) return false;
128  if (op_cd != src.op_cd) return false;
129  if (negate_d != src.negate_d) return false;
130  if (group_d != src.group_d) return false;
131 
132  return true;
133  }
134  bool operator!=(const Numcombine &src) const
135  {
136  return !operator==(src);
137  }
138 
139  };
140 
142  {
144 
145  buf.strcat("[ ");
146  for (int i = 0; i < list.entries(); i++)
147  {
148  if (i)
149  buf.strcat(", ");
150  buf.strcat("( ");
151  buf.append("");
152  buf.appendSprintf("%d", (int) list(i).grouptype);
153  buf.append(", ");
154  { UT_String tmp; tmp = UT_StringWrap(list(i).group).makeQuotedString('"'); buf.strcat(tmp); }
155  buf.append(", ");
156  buf.appendSprintf("%d", (int) list(i).negate_a);
157  buf.append(", ");
158  { UT_String tmp; tmp = UT_StringWrap(list(i).group_a).makeQuotedString('"'); buf.strcat(tmp); }
159  buf.append(", ");
160  buf.appendSprintf("%d", (int) list(i).op_ab);
161  buf.append(", ");
162  buf.appendSprintf("%d", (int) list(i).negate_b);
163  buf.append(", ");
164  { UT_String tmp; tmp = UT_StringWrap(list(i).group_b).makeQuotedString('"'); buf.strcat(tmp); }
165  buf.append(", ");
166  buf.appendSprintf("%d", (int) list(i).op_bc);
167  buf.append(", ");
168  buf.appendSprintf("%d", (int) list(i).negate_c);
169  buf.append(", ");
170  { UT_String tmp; tmp = UT_StringWrap(list(i).group_c).makeQuotedString('"'); buf.strcat(tmp); }
171  buf.append(", ");
172  buf.appendSprintf("%d", (int) list(i).op_cd);
173  buf.append(", ");
174  buf.appendSprintf("%d", (int) list(i).negate_d);
175  buf.append(", ");
176  { UT_String tmp; tmp = UT_StringWrap(list(i).group_d).makeQuotedString('"'); buf.strcat(tmp); }
177 
178  buf.strcat(" )");
179  }
180  buf.strcat(" ]");
181 
182  UT_StringHolder result = buf;
183  return result;
184  }
185 
187  {
188 
189  }
190 
191  explicit SOP_GroupCombineParms(const SOP_GroupCombineParms &) = default;
192 
194 
196  {
197  if (myNumcombine != src.myNumcombine) return false;
198 
199  return true;
200  }
202  {
203  return !operator==(src);
204  }
213 
214 
215 
216  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
217  {
218  if (true)
219  {
220  int64 length;
221  OP_Utils::evalOpParm(length, node, "numcombine", time, 0);
222  myNumcombine.entries(length);
223  for (exint i = 0; i < length; i++)
224  {
225  int parmidx = i+1;
226  auto && _curentry = myNumcombine(i);
227  (void) _curentry;
228  if (true)
229  OP_Utils::evalOpParmInst(myNumcombine(i).grouptype, node, "grouptype#", &parmidx, time, 0);
230  else myNumcombine(i).grouptype = 0;
231  if (true)
232  OP_Utils::evalOpParmInst(myNumcombine(i).group, node, "group#", &parmidx, time, 0);
233  else myNumcombine(i).group = ""_sh;
234  if (true)
235  OP_Utils::evalOpParmInst(myNumcombine(i).negate_a, node, "negate_a#", &parmidx, time, 0);
236  else myNumcombine(i).negate_a = 0;
237  if (true)
238  OP_Utils::evalOpParmInst(myNumcombine(i).group_a, node, "group_a#", &parmidx, time, 0);
239  else myNumcombine(i).group_a = ""_sh;
240  if (true)
241  OP_Utils::evalOpParmInst(myNumcombine(i).op_ab, node, "op_ab#", &parmidx, time, 0);
242  else myNumcombine(i).op_ab = 0;
243  if (true && ( (!(((_curentry.op_ab==0)))) ) )
244  OP_Utils::evalOpParmInst(myNumcombine(i).negate_b, node, "negate_b#", &parmidx, time, 0);
245  else myNumcombine(i).negate_b = 0;
246  if (true && ( (!(((_curentry.op_ab==0)))) ) )
247  OP_Utils::evalOpParmInst(myNumcombine(i).group_b, node, "group_b#", &parmidx, time, 0);
248  else myNumcombine(i).group_b = ""_sh;
249  if (true)
250  OP_Utils::evalOpParmInst(myNumcombine(i).op_bc, node, "op_bc#", &parmidx, time, 0);
251  else myNumcombine(i).op_bc = 0;
252  if (true && ( (!(((_curentry.op_bc==0)))) ) )
253  OP_Utils::evalOpParmInst(myNumcombine(i).negate_c, node, "negate_c#", &parmidx, time, 0);
254  else myNumcombine(i).negate_c = 0;
255  if (true && ( (!(((_curentry.op_bc==0)))) ) )
256  OP_Utils::evalOpParmInst(myNumcombine(i).group_c, node, "group_c#", &parmidx, time, 0);
257  else myNumcombine(i).group_c = ""_sh;
258  if (true)
259  OP_Utils::evalOpParmInst(myNumcombine(i).op_cd, node, "op_cd#", &parmidx, time, 0);
260  else myNumcombine(i).op_cd = 0;
261  if (true && ( (!(((_curentry.op_cd==0)))) ) )
262  OP_Utils::evalOpParmInst(myNumcombine(i).negate_d, node, "negate_d#", &parmidx, time, 0);
263  else myNumcombine(i).negate_d = 0;
264  if (true && ( (!(((_curentry.op_cd==0)))) ) )
265  OP_Utils::evalOpParmInst(myNumcombine(i).group_d, node, "group_d#", &parmidx, time, 0);
266  else myNumcombine(i).group_d = ""_sh;
267 
268  }
269  }
270  else
271  myNumcombine.clear();
272 
273  }
274 
275 
276  virtual void loadFromOpSubclass(const LoadParms &loadparms)
277  {
278  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
279  }
280 
281 
282  virtual void copyFrom(const SOP_NodeParms *src)
283  {
284  *this = *((const SOP_GroupCombineParms *)src);
285  }
286 
287  template <typename T>
288  void
289  doGetParmValue(exint idx, T &value) const
290  {
291  switch (idx)
292  {
293 
294  }
295  }
296 
297  void getParmValue(exint idx, exint &value) const
298  { doGetParmValue(idx, value); }
299  void getParmValue(exint idx, fpreal &value) const
300  { doGetParmValue(idx, value); }
302  { doGetParmValue(idx, value); }
304  { doGetParmValue(idx, value); }
306  { doGetParmValue(idx, value); }
308  { doGetParmValue(idx, value); }
310  { doGetParmValue(idx, value); }
312  { doGetParmValue(idx, value); }
314  { doGetParmValue(idx, value); }
316  { doGetParmValue(idx, value); }
318  { doGetParmValue(idx, value); }
319 
320  template <typename T>
321  void
322  doSetParmValue(exint idx, const T &value)
323  {
324  switch (idx)
325  {
326 
327  }
328  }
329 
330  void setParmValue(exint idx, const exint &value)
331  { doSetParmValue(idx, value); }
332  void setParmValue(exint idx, const fpreal &value)
333  { doSetParmValue(idx, value); }
334  void setParmValue(exint idx, const UT_Vector2D &value)
335  { doSetParmValue(idx, value); }
336  void setParmValue(exint idx, const UT_Vector3D &value)
337  { doSetParmValue(idx, value); }
338  void setParmValue(exint idx, const UT_Vector4D &value)
339  { doSetParmValue(idx, value); }
340  void setParmValue(exint idx, const UT_Matrix2D &value)
341  { doSetParmValue(idx, value); }
342  void setParmValue(exint idx, const UT_Matrix3D &value)
343  { doSetParmValue(idx, value); }
344  void setParmValue(exint idx, const UT_Matrix4D &value)
345  { doSetParmValue(idx, value); }
347  { doSetParmValue(idx, value); }
349  { doSetParmValue(idx, value); }
351  { doSetParmValue(idx, value); }
352 
353  virtual exint getNumParms() const
354  {
355  return 1;
356  }
357 
358  virtual const char *getParmName(exint fieldnum) const
359  {
360  switch (fieldnum)
361  {
362  case 0:
363  return "numcombine";
364 
365  }
366  return 0;
367  }
368 
369  virtual ParmType getParmType(exint fieldnum) const
370  {
371  switch (fieldnum)
372  {
373 
374  }
375  return PARM_UNSUPPORTED;
376  }
377 
378  // Boiler plate to load individual types.
379  static void loadData(UT_IStream &is, int64 &v)
380  { is.bread(&v, 1); }
381  static void loadData(UT_IStream &is, bool &v)
382  { int64 iv; is.bread(&iv, 1); v = iv; }
383  static void loadData(UT_IStream &is, fpreal64 &v)
384  { is.bread<fpreal64>(&v, 1); }
385  static void loadData(UT_IStream &is, UT_Vector2D &v)
386  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
387  static void loadData(UT_IStream &is, UT_Vector3D &v)
388  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
389  is.bread<fpreal64>(&v.z(), 1); }
390  static void loadData(UT_IStream &is, UT_Vector4D &v)
391  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
392  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
393  static void loadData(UT_IStream &is, UT_Matrix2D &v)
394  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
395  static void loadData(UT_IStream &is, UT_Matrix3D &v)
396  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
397  static void loadData(UT_IStream &is, UT_Matrix4D &v)
398  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
399  static void loadData(UT_IStream &is, UT_Vector2I &v)
400  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
401  static void loadData(UT_IStream &is, UT_Vector3I &v)
402  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
403  is.bread<int64>(&v.z(), 1); }
404  static void loadData(UT_IStream &is, UT_Vector4I &v)
405  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
406  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
408  { is.bread(v); }
410  { UT_StringHolder rampdata;
411  loadData(is, rampdata);
412  if (rampdata.isstring())
413  {
414  v.reset(new UT_Ramp());
415  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
416  v->load(istr);
417  }
418  else v.reset();
419  }
422  loadData(is, data);
423  if (data.isstring())
424  {
425  // Find the data type.
426  char *colon = UT_StringWrap(data).findChar(':');
427  if (colon)
428  {
429  int typelen = colon - data.buffer();
431  type.strncpy(data.buffer(), typelen);
432  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
433 
434  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
435  }
436  }
437  else v.reset();
438  }
439 
440  static void saveData(std::ostream &os, int64 v)
441  { UTwrite(os, &v); }
442  static void saveData(std::ostream &os, bool v)
443  { int64 iv = v; UTwrite(os, &iv); }
444  static void saveData(std::ostream &os, fpreal64 v)
445  { UTwrite<fpreal64>(os, &v); }
446  static void saveData(std::ostream &os, UT_Vector2D v)
447  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
448  static void saveData(std::ostream &os, UT_Vector3D v)
449  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
450  UTwrite<fpreal64>(os, &v.z()); }
451  static void saveData(std::ostream &os, UT_Vector4D v)
452  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
453  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
454  static void saveData(std::ostream &os, UT_Matrix2D v)
456  static void saveData(std::ostream &os, UT_Matrix3D v)
458  static void saveData(std::ostream &os, UT_Matrix4D v)
460  static void saveData(std::ostream &os, UT_StringHolder s)
461  { UT_StringWrap(s).saveBinary(os); }
462  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
463  { UT_StringHolder result;
464  UT_OStringStream ostr;
465  if (s) s->save(ostr);
466  result = ostr.str();
467  saveData(os, result);
468  }
469  static void saveData(std::ostream &os, PRM_DataItemHandle s)
470  { UT_StringHolder result;
471  UT_OStringStream ostr;
472  if (s)
473  {
474  ostr << s->getDataTypeToken();
475  ostr << ":";
476  s->saveBinary(ostr);
477  }
478  result = ostr.str();
479  saveData(os, result);
480  }
481 
482 
483  void save(std::ostream &os) const
484  {
485  int32 v = version();
486  UTwrite(os, &v);
487  {
488  int64 length = myNumcombine.entries();
489  UTwrite(os, &length);
490  for (exint i = 0; i < length; i++)
491  {
492  saveData(os, myNumcombine(i).grouptype);
493  saveData(os, myNumcombine(i).group);
494  saveData(os, myNumcombine(i).negate_a);
495  saveData(os, myNumcombine(i).group_a);
496  saveData(os, myNumcombine(i).op_ab);
497  saveData(os, myNumcombine(i).negate_b);
498  saveData(os, myNumcombine(i).group_b);
499  saveData(os, myNumcombine(i).op_bc);
500  saveData(os, myNumcombine(i).negate_c);
501  saveData(os, myNumcombine(i).group_c);
502  saveData(os, myNumcombine(i).op_cd);
503  saveData(os, myNumcombine(i).negate_d);
504  saveData(os, myNumcombine(i).group_d);
505 
506  }
507  }
508 
509  }
510 
511  bool load(UT_IStream &is)
512  {
513  int32 v;
514  is.bread(&v, 1);
515  if (version() != v)
516  {
517  // Fail incompatible versions
518  return false;
519  }
520  {
521  int64 length;
522  is.read(&length, 1);
523  myNumcombine.entries(length);
524  for (exint i = 0; i < length; i++)
525  {
526  loadData(is, myNumcombine(i).grouptype);
527  loadData(is, myNumcombine(i).group);
528  loadData(is, myNumcombine(i).negate_a);
529  loadData(is, myNumcombine(i).group_a);
530  loadData(is, myNumcombine(i).op_ab);
531  loadData(is, myNumcombine(i).negate_b);
532  loadData(is, myNumcombine(i).group_b);
533  loadData(is, myNumcombine(i).op_bc);
534  loadData(is, myNumcombine(i).negate_c);
535  loadData(is, myNumcombine(i).group_c);
536  loadData(is, myNumcombine(i).op_cd);
537  loadData(is, myNumcombine(i).negate_d);
538  loadData(is, myNumcombine(i).group_d);
539 
540  }
541  }
542 
543  return true;
544  }
545 
546  const UT_Array<Numcombine> &getNumcombine() const { return myNumcombine; }
547  void setNumcombine(const UT_Array<Numcombine> &val) { myNumcombine = val; }
549  {
550  SOP_Node *thissop = cookparms.getNode();
551  if (!thissop) return getNumcombine().entries();
552  exint result;
553  OP_Utils::evalOpParm(result, thissop, "numcombine", cookparms.getCookTime(), 0);
554  return result;
555  }
557  {
558  SOP_Node *thissop = cookparms.getNode();
559  if (!thissop) return (myNumcombine(_idx).grouptype);
560  int _parmidx = _idx + 1;
561  int64 result;
562  OP_Utils::evalOpParmInst(result, thissop, "grouptype#", &_parmidx, cookparms.getCookTime(), 0);
563  return (result);
564  }
566  {
567  SOP_Node *thissop = cookparms.getNode();
568  if (!thissop) return (myNumcombine(_idx).group);
569  int _parmidx = _idx + 1;
570  UT_StringHolder result;
571  OP_Utils::evalOpParmInst(result, thissop, "group#", &_parmidx, cookparms.getCookTime(), 0);
572  return (result);
573  }
575  {
576  SOP_Node *thissop = cookparms.getNode();
577  if (!thissop) return (myNumcombine(_idx).negate_a);
578  int _parmidx = _idx + 1;
579  int64 result;
580  OP_Utils::evalOpParmInst(result, thissop, "negate_a#", &_parmidx, cookparms.getCookTime(), 0);
581  return (result);
582  }
584  {
585  SOP_Node *thissop = cookparms.getNode();
586  if (!thissop) return (myNumcombine(_idx).group_a);
587  int _parmidx = _idx + 1;
588  UT_StringHolder result;
589  OP_Utils::evalOpParmInst(result, thissop, "group_a#", &_parmidx, cookparms.getCookTime(), 0);
590  return (result);
591  }
593  {
594  SOP_Node *thissop = cookparms.getNode();
595  if (!thissop) return (myNumcombine(_idx).op_ab);
596  int _parmidx = _idx + 1;
597  int64 result;
598  OP_Utils::evalOpParmInst(result, thissop, "op_ab#", &_parmidx, cookparms.getCookTime(), 0);
599  return (result);
600  }
602  {
603  SOP_Node *thissop = cookparms.getNode();
604  if (!thissop) return (myNumcombine(_idx).negate_b);
605  int _parmidx = _idx + 1;
606  int64 result;
607  OP_Utils::evalOpParmInst(result, thissop, "negate_b#", &_parmidx, cookparms.getCookTime(), 0);
608  return (result);
609  }
611  {
612  SOP_Node *thissop = cookparms.getNode();
613  if (!thissop) return (myNumcombine(_idx).group_b);
614  int _parmidx = _idx + 1;
615  UT_StringHolder result;
616  OP_Utils::evalOpParmInst(result, thissop, "group_b#", &_parmidx, cookparms.getCookTime(), 0);
617  return (result);
618  }
620  {
621  SOP_Node *thissop = cookparms.getNode();
622  if (!thissop) return (myNumcombine(_idx).op_bc);
623  int _parmidx = _idx + 1;
624  int64 result;
625  OP_Utils::evalOpParmInst(result, thissop, "op_bc#", &_parmidx, cookparms.getCookTime(), 0);
626  return (result);
627  }
629  {
630  SOP_Node *thissop = cookparms.getNode();
631  if (!thissop) return (myNumcombine(_idx).negate_c);
632  int _parmidx = _idx + 1;
633  int64 result;
634  OP_Utils::evalOpParmInst(result, thissop, "negate_c#", &_parmidx, cookparms.getCookTime(), 0);
635  return (result);
636  }
638  {
639  SOP_Node *thissop = cookparms.getNode();
640  if (!thissop) return (myNumcombine(_idx).group_c);
641  int _parmidx = _idx + 1;
642  UT_StringHolder result;
643  OP_Utils::evalOpParmInst(result, thissop, "group_c#", &_parmidx, cookparms.getCookTime(), 0);
644  return (result);
645  }
647  {
648  SOP_Node *thissop = cookparms.getNode();
649  if (!thissop) return (myNumcombine(_idx).op_cd);
650  int _parmidx = _idx + 1;
651  int64 result;
652  OP_Utils::evalOpParmInst(result, thissop, "op_cd#", &_parmidx, cookparms.getCookTime(), 0);
653  return (result);
654  }
656  {
657  SOP_Node *thissop = cookparms.getNode();
658  if (!thissop) return (myNumcombine(_idx).negate_d);
659  int _parmidx = _idx + 1;
660  int64 result;
661  OP_Utils::evalOpParmInst(result, thissop, "negate_d#", &_parmidx, cookparms.getCookTime(), 0);
662  return (result);
663  }
665  {
666  SOP_Node *thissop = cookparms.getNode();
667  if (!thissop) return (myNumcombine(_idx).group_d);
668  int _parmidx = _idx + 1;
669  UT_StringHolder result;
670  OP_Utils::evalOpParmInst(result, thissop, "group_d#", &_parmidx, cookparms.getCookTime(), 0);
671  return (result);
672  }
673 
674 
675 private:
676  UT_Array<Numcombine> myNumcombine;
677 
678 };
void getParmValue(exint idx, PRM_DataItemHandle &value) const
void getParmValue(exint idx, UT_Vector2D &value) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
void getParmValue(exint idx, UT_Vector3D &value) const
void doSetParmValue(exint idx, const T &value)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
T & z(void)
Definition: UT_Vector4.h:379
int64 opNumcombine_negate_c(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
static void saveData(std::ostream &os, UT_Matrix3D v)
bool operator==(const Numcombine &src) const
static void saveData(std::ostream &os, UT_Vector4D v)
virtual void copyFrom(const SOP_NodeParms *src)
int64 opNumcombine_op_cd(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
fpreal getTime() const
Definition: OP_Context.h:60
const GLdouble * v
Definition: glcorearb.h:836
static void saveData(std::ostream &os, int64 v)
typedef void(APIENTRYP PFNGLCULLFACEPROC)(GLenum mode)
UT_String makeQuotedString(char delimiter='\'', bool escape_nonprinting=false) const
void getParmValue(exint idx, fpreal &value) const
int64 opNumcombine_op_ab(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
void setParmValue(exint idx, const exint &value)
void getParmValue(exint idx, UT_Vector4D &value) const
An output stream object that owns its own string buffer storage.
static void loadData(UT_IStream &is, UT_StringHolder &v)
UT_StringHolder opNumcombine_group_a(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
static void saveData(std::ostream &os, bool v)
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void setParmValue(exint idx, const UT_Matrix2D &value)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
virtual exint getNumParms() const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
bool load(UT_IStream &is)
png_uint_32 i
Definition: png.h:2877
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
static void saveData(std::ostream &os, UT_Vector3D v)
void save(std::ostream &os) 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
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_Array< Numcombine > & getNumcombine() const
long long int64
Definition: SYS_Types.h:107
static void loadData(UT_IStream &is, fpreal64 &v)
void getParmValue(exint idx, UT_Matrix3D &value) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
UT_StringHolder opNumcombine_group_d(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
bool operator==(const SOP_GroupCombineParms &src) const
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
void setParmValue(exint idx, const PRM_DataItemHandle &value)
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
int64 exint
Definition: SYS_Types.h:116
exint opNumcombine(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
double fpreal64
Definition: SYS_Types.h:192
void getParmValue(exint idx, UT_StringHolder &value) const
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:284
int64 opNumcombine_negate_b(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
void getParmValue(exint idx, UT_Matrix2D &value) const
virtual ParmType getParmType(exint fieldnum) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
virtual const char * getParmName(exint fieldnum) const
bool operator!=(const Numcombine &src) const
void getParmValue(exint idx, exint &value) const
UT_StringHolder createString(const UT_Array< Numcombine > &list) const
int64 opNumcombine_grouptype(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
int64 opNumcombine_op_bc(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void setParmValue(exint idx, const UT_Vector3D &value)
GLboolean * data
Definition: glcorearb.h:130
int int32
Definition: SYS_Types.h:35
T & y(void)
Definition: UT_Vector4.h:377
void setParmValue(exint idx, const UT_Vector4D &value)
static void loadData(UT_IStream &is, UT_Vector4I &v)
static void loadData(UT_IStream &is, int64 &v)
static void loadData(UT_IStream &is, bool &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_Vector4D &v)
void setNumcombine(const UT_Array< Numcombine > &val)
void setParmValue(exint idx, const UT_Matrix3D &value)
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, fpreal64 v)
static void saveData(std::ostream &os, UT_StringHolder s)
int64 opNumcombine_negate_d(const SOP_NodeVerb::CookParms &cookparms, exint _idx) 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
static void loadData(UT_IStream &is, UT_Vector3I &v)
static void loadData(UT_IStream &is, UT_Vector3D &v)
int int appendSprintf(const char *fmt,...) SYS_PRINTF_CHECK_ATTRIBUTE(2
int64 opNumcombine_negate_a(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
virtual void loadFromOpSubclass(const LoadParms &loadparms)
UT_StringHolder opNumcombine_group_b(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
UT_StringHolder opNumcombine_group_c(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void getParmValue(exint idx, UT_Matrix4D &value) const
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
static void saveData(std::ostream &os, UT_Matrix2D v)
SYS_FORCE_INLINE void append(char character)
static void loadData(UT_IStream &is, UT_Matrix3D &v)
GLuint GLfloat * val
Definition: glcorearb.h:1607
void setParmValue(exint idx, const UT_Matrix4D &value)
#define SOP_API
Definition: SOP_API.h:10
void setParmValue(exint idx, const UT_Vector2D &value)
static void saveData(std::ostream &os, PRM_DataItemHandle s)
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 setParmValue(exint idx, const fpreal &value)
T & y(void)
Definition: UT_Vector2.h:287
GLboolean r
Definition: glcorearb.h:1221
static void loadData(UT_IStream &is, UT_Vector2D &v)
T & w(void)
Definition: UT_Vector4.h:381
bool operator!=(const SOP_GroupCombineParms &src) const
UT_StringHolder opNumcombine_group(const SOP_NodeVerb::CookParms &cookparms, exint _idx) const
void setParmValue(exint idx, const UT_StringHolder &value)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
void doGetParmValue(exint idx, T &value) const
SYS_FORCE_INLINE bool isstring() const
static void saveData(std::ostream &os, UT_Matrix4D v)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
GLenum src
Definition: glcorearb.h:1792