HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros 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 
135  };
136 
138  {
140 
141  buf.strcat("[ ");
142  for (int i = 0; i < list.entries(); i++)
143  {
144  if (i)
145  buf.strcat(", ");
146  buf.strcat("( ");
147  buf.append("");
148  buf.appendSprintf("%d", (int) list(i).grouptype);
149  buf.append(", ");
150  { UT_String tmp; tmp = UT_StringWrap(list(i).group).makeQuotedString('"'); buf.strcat(tmp); }
151  buf.append(", ");
152  buf.appendSprintf("%d", (int) list(i).negate_a);
153  buf.append(", ");
154  { UT_String tmp; tmp = UT_StringWrap(list(i).group_a).makeQuotedString('"'); buf.strcat(tmp); }
155  buf.append(", ");
156  buf.appendSprintf("%d", (int) list(i).op_ab);
157  buf.append(", ");
158  buf.appendSprintf("%d", (int) list(i).negate_b);
159  buf.append(", ");
160  { UT_String tmp; tmp = UT_StringWrap(list(i).group_b).makeQuotedString('"'); buf.strcat(tmp); }
161  buf.append(", ");
162  buf.appendSprintf("%d", (int) list(i).op_bc);
163  buf.append(", ");
164  buf.appendSprintf("%d", (int) list(i).negate_c);
165  buf.append(", ");
166  { UT_String tmp; tmp = UT_StringWrap(list(i).group_c).makeQuotedString('"'); buf.strcat(tmp); }
167  buf.append(", ");
168  buf.appendSprintf("%d", (int) list(i).op_cd);
169  buf.append(", ");
170  buf.appendSprintf("%d", (int) list(i).negate_d);
171  buf.append(", ");
172  { UT_String tmp; tmp = UT_StringWrap(list(i).group_d).makeQuotedString('"'); buf.strcat(tmp); }
173 
174  buf.strcat(" )");
175  }
176  buf.strcat(" ]");
177 
178  UT_StringHolder result = buf;
179  return result;
180  }
181 
183  {
184 
185  }
186 
187  explicit SOP_GroupCombineParms(const SOP_GroupCombineParms &) = default;
188 
190 
192  {
193  if (myNumcombine != src.myNumcombine) return false;
194 
195  return true;
196  }
205 
206 
207 
208  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
209  {
210  if (true)
211  {
212  int64 length;
213  OP_Utils::evalOpParm(length, node, "numcombine", time, 0);
214  myNumcombine.entries(length);
215  for (exint i = 0; i < length; i++)
216  {
217  int parmidx = i+1;
218  auto && _curentry = myNumcombine(i);
219  (void) _curentry;
220  if (true)
221  OP_Utils::evalOpParmInst(myNumcombine(i).grouptype, node, "grouptype#", &parmidx, time, 0);
222  else myNumcombine(i).grouptype = 0;
223  if (true)
224  OP_Utils::evalOpParmInst(myNumcombine(i).group, node, "group#", &parmidx, time, 0);
225  else myNumcombine(i).group = ""_sh;
226  if (true)
227  OP_Utils::evalOpParmInst(myNumcombine(i).negate_a, node, "negate_a#", &parmidx, time, 0);
228  else myNumcombine(i).negate_a = 0;
229  if (true)
230  OP_Utils::evalOpParmInst(myNumcombine(i).group_a, node, "group_a#", &parmidx, time, 0);
231  else myNumcombine(i).group_a = ""_sh;
232  if (true)
233  OP_Utils::evalOpParmInst(myNumcombine(i).op_ab, node, "op_ab#", &parmidx, time, 0);
234  else myNumcombine(i).op_ab = 0;
235  if (true && ( (!(((_curentry.op_ab==0)))) ) )
236  OP_Utils::evalOpParmInst(myNumcombine(i).negate_b, node, "negate_b#", &parmidx, time, 0);
237  else myNumcombine(i).negate_b = 0;
238  if (true && ( (!(((_curentry.op_ab==0)))) ) )
239  OP_Utils::evalOpParmInst(myNumcombine(i).group_b, node, "group_b#", &parmidx, time, 0);
240  else myNumcombine(i).group_b = ""_sh;
241  if (true)
242  OP_Utils::evalOpParmInst(myNumcombine(i).op_bc, node, "op_bc#", &parmidx, time, 0);
243  else myNumcombine(i).op_bc = 0;
244  if (true && ( (!(((_curentry.op_bc==0)))) ) )
245  OP_Utils::evalOpParmInst(myNumcombine(i).negate_c, node, "negate_c#", &parmidx, time, 0);
246  else myNumcombine(i).negate_c = 0;
247  if (true && ( (!(((_curentry.op_bc==0)))) ) )
248  OP_Utils::evalOpParmInst(myNumcombine(i).group_c, node, "group_c#", &parmidx, time, 0);
249  else myNumcombine(i).group_c = ""_sh;
250  if (true)
251  OP_Utils::evalOpParmInst(myNumcombine(i).op_cd, node, "op_cd#", &parmidx, time, 0);
252  else myNumcombine(i).op_cd = 0;
253  if (true && ( (!(((_curentry.op_cd==0)))) ) )
254  OP_Utils::evalOpParmInst(myNumcombine(i).negate_d, node, "negate_d#", &parmidx, time, 0);
255  else myNumcombine(i).negate_d = 0;
256  if (true && ( (!(((_curentry.op_cd==0)))) ) )
257  OP_Utils::evalOpParmInst(myNumcombine(i).group_d, node, "group_d#", &parmidx, time, 0);
258  else myNumcombine(i).group_d = ""_sh;
259 
260  }
261  }
262  else
263  myNumcombine.clear();
264 
265  }
266 
267 
268  virtual void loadFromOpSubclass(const LoadParms &loadparms)
269  {
270  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
271  }
272 
273 
274  virtual void copyFrom(const SOP_NodeParms *src)
275  {
276  *this = *((const SOP_GroupCombineParms *)src);
277  }
278 
279  template <typename T>
280  void
281  doGetParmValue(exint idx, T &value) const
282  {
283  switch (idx)
284  {
285 
286  }
287  }
288 
289  void getParmValue(exint idx, exint &value) const
290  { doGetParmValue(idx, value); }
291  void getParmValue(exint idx, fpreal &value) const
292  { doGetParmValue(idx, value); }
294  { doGetParmValue(idx, value); }
296  { doGetParmValue(idx, value); }
298  { doGetParmValue(idx, value); }
300  { doGetParmValue(idx, value); }
302  { doGetParmValue(idx, value); }
304  { doGetParmValue(idx, value); }
306  { doGetParmValue(idx, value); }
308  { doGetParmValue(idx, value); }
310  { doGetParmValue(idx, value); }
311 
312  template <typename T>
313  void
314  doSetParmValue(exint idx, const T &value)
315  {
316  switch (idx)
317  {
318 
319  }
320  }
321 
322  void setParmValue(exint idx, const exint &value)
323  { doSetParmValue(idx, value); }
324  void setParmValue(exint idx, const fpreal &value)
325  { doSetParmValue(idx, value); }
326  void setParmValue(exint idx, const UT_Vector2D &value)
327  { doSetParmValue(idx, value); }
328  void setParmValue(exint idx, const UT_Vector3D &value)
329  { doSetParmValue(idx, value); }
330  void setParmValue(exint idx, const UT_Vector4D &value)
331  { doSetParmValue(idx, value); }
332  void setParmValue(exint idx, const UT_Matrix2D &value)
333  { doSetParmValue(idx, value); }
334  void setParmValue(exint idx, const UT_Matrix3D &value)
335  { doSetParmValue(idx, value); }
336  void setParmValue(exint idx, const UT_Matrix4D &value)
337  { doSetParmValue(idx, value); }
339  { doSetParmValue(idx, value); }
341  { doSetParmValue(idx, value); }
343  { doSetParmValue(idx, value); }
344 
345  virtual exint getNumParms() const
346  {
347  return 1;
348  }
349 
350  virtual const char *getParmName(exint fieldnum) const
351  {
352  switch (fieldnum)
353  {
354  case 0:
355  return "numcombine";
356 
357  }
358  return 0;
359  }
360 
361  virtual ParmType getParmType(exint fieldnum) const
362  {
363  switch (fieldnum)
364  {
365 
366  }
367  return PARM_UNSUPPORTED;
368  }
369 
370  // Boiler plate to load individual types.
371  static void loadData(UT_IStream &is, int64 &v)
372  { is.bread(&v, 1); }
373  static void loadData(UT_IStream &is, bool &v)
374  { int64 iv; is.bread(&iv, 1); v = iv; }
375  static void loadData(UT_IStream &is, fpreal64 &v)
376  { is.bread<fpreal64>(&v, 1); }
377  static void loadData(UT_IStream &is, UT_Vector2D &v)
378  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
379  static void loadData(UT_IStream &is, UT_Vector3D &v)
380  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
381  is.bread<fpreal64>(&v.z(), 1); }
382  static void loadData(UT_IStream &is, UT_Vector4D &v)
383  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
384  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
385  static void loadData(UT_IStream &is, UT_Matrix2D &v)
386  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
387  static void loadData(UT_IStream &is, UT_Matrix3D &v)
388  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
389  static void loadData(UT_IStream &is, UT_Matrix4D &v)
390  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
391  static void loadData(UT_IStream &is, UT_Vector2I &v)
392  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
393  static void loadData(UT_IStream &is, UT_Vector3I &v)
394  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
395  is.bread<int64>(&v.z(), 1); }
396  static void loadData(UT_IStream &is, UT_Vector4I &v)
397  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
398  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
400  { is.bread(v); }
402  { UT_StringHolder rampdata;
403  loadData(is, rampdata);
404  if (rampdata.isstring())
405  {
406  v.reset(new UT_Ramp());
407  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
408  v->load(istr);
409  }
410  else v.reset();
411  }
414  loadData(is, data);
415  if (data.isstring())
416  {
417  // Find the data type.
418  char *colon = UT_StringWrap(data).findChar(':');
419  if (colon)
420  {
421  int typelen = colon - data.buffer();
423  type.strncpy(data.buffer(), typelen);
424  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
425 
426  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
427  }
428  }
429  else v.reset();
430  }
431 
432  static void saveData(std::ostream &os, int64 v)
433  { UTwrite(os, &v); }
434  static void saveData(std::ostream &os, bool v)
435  { int64 iv = v; UTwrite(os, &iv); }
436  static void saveData(std::ostream &os, fpreal64 v)
437  { UTwrite<fpreal64>(os, &v); }
438  static void saveData(std::ostream &os, UT_Vector2D v)
439  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
440  static void saveData(std::ostream &os, UT_Vector3D v)
441  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
442  UTwrite<fpreal64>(os, &v.z()); }
443  static void saveData(std::ostream &os, UT_Vector4D v)
444  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
445  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
446  static void saveData(std::ostream &os, UT_Matrix2D v)
448  static void saveData(std::ostream &os, UT_Matrix3D v)
450  static void saveData(std::ostream &os, UT_Matrix4D v)
452  static void saveData(std::ostream &os, UT_StringHolder s)
453  { UT_StringWrap(s).saveBinary(os); }
454  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
455  { UT_StringHolder result;
456  UT_OStringStream ostr;
457  if (s) s->save(ostr);
458  result = ostr.str();
459  saveData(os, result);
460  }
461  static void saveData(std::ostream &os, PRM_DataItemHandle s)
462  { UT_StringHolder result;
463  UT_OStringStream ostr;
464  if (s)
465  {
466  ostr << s->getDataTypeToken();
467  ostr << ":";
468  s->saveBinary(ostr);
469  }
470  result = ostr.str();
471  saveData(os, result);
472  }
473 
474 
475  void save(std::ostream &os) const
476  {
477  int32 v = version();
478  UTwrite(os, &v);
479  {
480  int64 length = myNumcombine.entries();
481  UTwrite(os, &length);
482  for (exint i = 0; i < length; i++)
483  {
484  saveData(os, myNumcombine(i).grouptype);
485  saveData(os, myNumcombine(i).group);
486  saveData(os, myNumcombine(i).negate_a);
487  saveData(os, myNumcombine(i).group_a);
488  saveData(os, myNumcombine(i).op_ab);
489  saveData(os, myNumcombine(i).negate_b);
490  saveData(os, myNumcombine(i).group_b);
491  saveData(os, myNumcombine(i).op_bc);
492  saveData(os, myNumcombine(i).negate_c);
493  saveData(os, myNumcombine(i).group_c);
494  saveData(os, myNumcombine(i).op_cd);
495  saveData(os, myNumcombine(i).negate_d);
496  saveData(os, myNumcombine(i).group_d);
497 
498  }
499  }
500 
501  }
502 
503  bool load(UT_IStream &is)
504  {
505  int32 v;
506  is.bread(&v, 1);
507  if (version() != v)
508  {
509  // Fail incompatible versions
510  return false;
511  }
512  {
513  int64 length;
514  is.read(&length, 1);
515  myNumcombine.entries(length);
516  for (exint i = 0; i < length; i++)
517  {
518  loadData(is, myNumcombine(i).grouptype);
519  loadData(is, myNumcombine(i).group);
520  loadData(is, myNumcombine(i).negate_a);
521  loadData(is, myNumcombine(i).group_a);
522  loadData(is, myNumcombine(i).op_ab);
523  loadData(is, myNumcombine(i).negate_b);
524  loadData(is, myNumcombine(i).group_b);
525  loadData(is, myNumcombine(i).op_bc);
526  loadData(is, myNumcombine(i).negate_c);
527  loadData(is, myNumcombine(i).group_c);
528  loadData(is, myNumcombine(i).op_cd);
529  loadData(is, myNumcombine(i).negate_d);
530  loadData(is, myNumcombine(i).group_d);
531 
532  }
533  }
534 
535  return true;
536  }
537 
538  const UT_Array<Numcombine> &getNumcombine() const { return myNumcombine; }
539  void setNumcombine(const UT_Array<Numcombine> &val) { myNumcombine = val; }
541  {
542  SOP_Node *thissop = cookparms.getNode();
543  if (!thissop) return getNumcombine().entries();
544  exint result;
545  OP_Utils::evalOpParm(result, thissop, "numcombine", cookparms.getCookTime(), 0);
546  return result;
547  }
549  {
550  SOP_Node *thissop = cookparms.getNode();
551  if (!thissop) return (myNumcombine(_idx).grouptype);
552  int _parmidx = _idx + 1;
553  int64 result;
554  OP_Utils::evalOpParmInst(result, thissop, "grouptype#", &_parmidx, cookparms.getCookTime(), 0);
555  return (result);
556  }
558  {
559  SOP_Node *thissop = cookparms.getNode();
560  if (!thissop) return (myNumcombine(_idx).group);
561  int _parmidx = _idx + 1;
562  UT_StringHolder result;
563  OP_Utils::evalOpParmInst(result, thissop, "group#", &_parmidx, cookparms.getCookTime(), 0);
564  return (result);
565  }
567  {
568  SOP_Node *thissop = cookparms.getNode();
569  if (!thissop) return (myNumcombine(_idx).negate_a);
570  int _parmidx = _idx + 1;
571  int64 result;
572  OP_Utils::evalOpParmInst(result, thissop, "negate_a#", &_parmidx, cookparms.getCookTime(), 0);
573  return (result);
574  }
576  {
577  SOP_Node *thissop = cookparms.getNode();
578  if (!thissop) return (myNumcombine(_idx).group_a);
579  int _parmidx = _idx + 1;
580  UT_StringHolder result;
581  OP_Utils::evalOpParmInst(result, thissop, "group_a#", &_parmidx, cookparms.getCookTime(), 0);
582  return (result);
583  }
585  {
586  SOP_Node *thissop = cookparms.getNode();
587  if (!thissop) return (myNumcombine(_idx).op_ab);
588  int _parmidx = _idx + 1;
589  int64 result;
590  OP_Utils::evalOpParmInst(result, thissop, "op_ab#", &_parmidx, cookparms.getCookTime(), 0);
591  return (result);
592  }
594  {
595  SOP_Node *thissop = cookparms.getNode();
596  if (!thissop) return (myNumcombine(_idx).negate_b);
597  int _parmidx = _idx + 1;
598  int64 result;
599  OP_Utils::evalOpParmInst(result, thissop, "negate_b#", &_parmidx, cookparms.getCookTime(), 0);
600  return (result);
601  }
603  {
604  SOP_Node *thissop = cookparms.getNode();
605  if (!thissop) return (myNumcombine(_idx).group_b);
606  int _parmidx = _idx + 1;
607  UT_StringHolder result;
608  OP_Utils::evalOpParmInst(result, thissop, "group_b#", &_parmidx, cookparms.getCookTime(), 0);
609  return (result);
610  }
612  {
613  SOP_Node *thissop = cookparms.getNode();
614  if (!thissop) return (myNumcombine(_idx).op_bc);
615  int _parmidx = _idx + 1;
616  int64 result;
617  OP_Utils::evalOpParmInst(result, thissop, "op_bc#", &_parmidx, cookparms.getCookTime(), 0);
618  return (result);
619  }
621  {
622  SOP_Node *thissop = cookparms.getNode();
623  if (!thissop) return (myNumcombine(_idx).negate_c);
624  int _parmidx = _idx + 1;
625  int64 result;
626  OP_Utils::evalOpParmInst(result, thissop, "negate_c#", &_parmidx, cookparms.getCookTime(), 0);
627  return (result);
628  }
630  {
631  SOP_Node *thissop = cookparms.getNode();
632  if (!thissop) return (myNumcombine(_idx).group_c);
633  int _parmidx = _idx + 1;
634  UT_StringHolder result;
635  OP_Utils::evalOpParmInst(result, thissop, "group_c#", &_parmidx, cookparms.getCookTime(), 0);
636  return (result);
637  }
639  {
640  SOP_Node *thissop = cookparms.getNode();
641  if (!thissop) return (myNumcombine(_idx).op_cd);
642  int _parmidx = _idx + 1;
643  int64 result;
644  OP_Utils::evalOpParmInst(result, thissop, "op_cd#", &_parmidx, cookparms.getCookTime(), 0);
645  return (result);
646  }
648  {
649  SOP_Node *thissop = cookparms.getNode();
650  if (!thissop) return (myNumcombine(_idx).negate_d);
651  int _parmidx = _idx + 1;
652  int64 result;
653  OP_Utils::evalOpParmInst(result, thissop, "negate_d#", &_parmidx, cookparms.getCookTime(), 0);
654  return (result);
655  }
657  {
658  SOP_Node *thissop = cookparms.getNode();
659  if (!thissop) return (myNumcombine(_idx).group_d);
660  int _parmidx = _idx + 1;
661  UT_StringHolder result;
662  OP_Utils::evalOpParmInst(result, thissop, "group_d#", &_parmidx, cookparms.getCookTime(), 0);
663  return (result);
664  }
665 
666 
667 private:
668  UT_Array<Numcombine> myNumcombine;
669 
670 };
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:492
T & z(void)
Definition: UT_Vector4.h:372
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)
fpreal getTime() const
Definition: OP_Context.h:34
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
T & x(void)
Definition: UT_Vector2.h:284
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:581
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:585
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_Array< Numcombine > & getNumcombine() const
long long int64
Definition: SYS_Types.h:106
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 append(char character)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
SYS_FORCE_INLINE const char * buffer() const
int64 exint
Definition: SYS_Types.h:115
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:191
void getParmValue(exint idx, UT_StringHolder &value) const
exint read(bool *array, exint sz=1)
Definition: UT_IStream.h:280
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
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:34
T & y(void)
Definition: UT_Vector4.h:370
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)
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)
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:446
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:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:269
static void loadData(UT_IStream &is, UT_Vector3I &v)
void strncpy(const char *src, exint maxlen)
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)
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)
const char * buffer() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
T & x(void)
Definition: UT_Vector4.h:368
void setParmValue(exint idx, const fpreal &value)
T & y(void)
Definition: UT_Vector2.h:286
GLboolean r
Definition: glcorearb.h:1221
static void loadData(UT_IStream &is, UT_Vector2D &v)
void strcat(const char *src)
T & w(void)
Definition: UT_Vector4.h:374
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
void doGetParmValue(exint idx, T &value) const
SYS_FORCE_INLINE bool isstring() const
static void saveData(std::ostream &os, UT_Matrix4D v)
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:794
GLenum src
Definition: glcorearb.h:1792