HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_EdgeTransport.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_EdgeTransportEnums
22 {
23  enum class Method
24  {
25  CURVE = 0,
26  NET,
27  PARENT
28  };
29  enum class CurveDir
30  {
31  FORWARD = 0,
32  BACKWARD
33  };
34  enum class RootType
35  {
36  FIRST = 0,
37  LAST,
38  GROUP
39  };
40  enum class Operation
41  {
42  COPY = 0,
43  COPYROOT,
44  SUM,
45  MAX,
46  MIN
47  };
48  enum class RootValue
49  {
50  ZERO = 0,
51  HOLD
52  };
53  enum class SplitMethod
54  {
55  COPY = 0,
56  SPLIT
57  };
58  enum class MergeMethod
59  {
60  SUM = 0,
61  MAX,
62  MIN
63  };
64 }
65 
66 
68 {
69 public:
70  static int version() { return 1; }
71 
73  {
74  myMethod = 0;
75  myPointGroup = ""_sh;
76  myPrimitiveGroup = ""_sh;
77  myAttribute = "distance"_sh;
78  myCurveDir = 0;
79  myParentAttribute = "parent"_sh;
80  myRootType = 0;
81  myRootGroup = "0"_sh;
82  myOperation = 2;
83  myRootValue = 0;
84  myIgnoreAttribute = false;
85  myScaleByEdge = false;
86  mySplitMethod = 0;
87  myMergeMethod = 0;
88 
89  }
90 
91  explicit SOP_EdgeTransportParms(const SOP_EdgeTransportParms &) = default;
92 
94 
96  {
97  if (myMethod != src.myMethod) return false;
98  if (myPointGroup != src.myPointGroup) return false;
99  if (myPrimitiveGroup != src.myPrimitiveGroup) return false;
100  if (myAttribute != src.myAttribute) return false;
101  if (myCurveDir != src.myCurveDir) return false;
102  if (myParentAttribute != src.myParentAttribute) return false;
103  if (myRootType != src.myRootType) return false;
104  if (myRootGroup != src.myRootGroup) return false;
105  if (myOperation != src.myOperation) return false;
106  if (myRootValue != src.myRootValue) return false;
107  if (myIgnoreAttribute != src.myIgnoreAttribute) return false;
108  if (myScaleByEdge != src.myScaleByEdge) return false;
109  if (mySplitMethod != src.mySplitMethod) return false;
110  if (myMergeMethod != src.myMergeMethod) return false;
111 
112  return true;
113  }
121 
122 
123 
124  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
125  {
126  if (true)
127  OP_Utils::evalOpParm(myMethod, node, "method", time, 0);
128  else myMethod = 0;
129  if (true && ( (!(((int64(getMethod())==0)))) ) )
130  OP_Utils::evalOpParm(myPointGroup, node, "ptgroup", time, 0);
131  else myPointGroup = ""_sh;
132  if (true && ( (!(((int64(getMethod())!=0)))) ) )
133  OP_Utils::evalOpParm(myPrimitiveGroup, node, "primgroup", time, 0);
134  else myPrimitiveGroup = ""_sh;
135  if (true)
136  OP_Utils::evalOpParm(myAttribute, node, "attribute", time, 0);
137  else myAttribute = "distance"_sh;
138  if (true)
139  OP_Utils::evalOpParm(myCurveDir, node, "curvedir", time, 0);
140  else myCurveDir = 0;
141  if (true && ( (!(((int64(getMethod())!=2)))) ) )
142  OP_Utils::evalOpParm(myParentAttribute, node, "parentattribute", time, 0);
143  else myParentAttribute = "parent"_sh;
144  if (true && ( (!(((int64(getMethod())!=1)))) ) )
145  OP_Utils::evalOpParm(myRootType, node, "roottype", time, 0);
146  else myRootType = 0;
147  if (true && ( (!(((int64(getRootType())!=2))||((int64(getMethod())!=1)))) ) )
148  OP_Utils::evalOpParm(myRootGroup, node, "rootgroup", time, 0);
149  else myRootGroup = "0"_sh;
150  if (true)
151  OP_Utils::evalOpParm(myOperation, node, "operation", time, 0);
152  else myOperation = 2;
153  if (true && ( (!(((int64(getOperation())!=0)))) ) )
154  OP_Utils::evalOpParm(myRootValue, node, "rootvalue", time, 0);
155  else myRootValue = 0;
156  if (true && ( (!(((int64(getOperation())!=2)))) ) )
157  OP_Utils::evalOpParm(myIgnoreAttribute, node, "ignoreattribute", time, 0);
158  else myIgnoreAttribute = false;
159  if (true && ( (!(((int64(getOperation())!=2)))) ) )
160  OP_Utils::evalOpParm(myScaleByEdge, node, "scalebyedge", time, 0);
161  else myScaleByEdge = false;
162  if (true && ( (!(((int64(getMethod())==0))||((int64(getCurveDir())!=0)))) ) )
163  OP_Utils::evalOpParm(mySplitMethod, node, "splitmethod", time, 0);
164  else mySplitMethod = 0;
165  if (true && ( (!(((int64(getMethod())==0))||((int64(getCurveDir())!=1)))) ) )
166  OP_Utils::evalOpParm(myMergeMethod, node, "mergemethod", time, 0);
167  else myMergeMethod = 0;
168 
169  }
170 
171 
172  virtual void loadFromOpSubclass(const LoadParms &loadparms)
173  {
174  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
175  }
176 
177 
178  virtual void copyFrom(const SOP_NodeParms *src)
179  {
180  *this = *((const SOP_EdgeTransportParms *)src);
181  }
182 
183  template <typename T>
184  void
185  doGetParmValue(exint idx, T &value) const
186  {
187  switch (idx)
188  {
189  case 0:
190  coerceValue(value, myMethod);
191  break;
192  case 1:
193  coerceValue(value, myPointGroup);
194  break;
195  case 2:
196  coerceValue(value, myPrimitiveGroup);
197  break;
198  case 3:
199  coerceValue(value, myAttribute);
200  break;
201  case 4:
202  coerceValue(value, myCurveDir);
203  break;
204  case 5:
205  coerceValue(value, myParentAttribute);
206  break;
207  case 6:
208  coerceValue(value, myRootType);
209  break;
210  case 7:
211  coerceValue(value, myRootGroup);
212  break;
213  case 8:
214  coerceValue(value, myOperation);
215  break;
216  case 9:
217  coerceValue(value, myRootValue);
218  break;
219  case 10:
220  coerceValue(value, myIgnoreAttribute);
221  break;
222  case 11:
223  coerceValue(value, myScaleByEdge);
224  break;
225  case 12:
226  coerceValue(value, mySplitMethod);
227  break;
228  case 13:
229  coerceValue(value, myMergeMethod);
230  break;
231 
232  }
233  }
234 
235  void getParmValue(exint idx, exint &value) const
236  { doGetParmValue(idx, value); }
237  void getParmValue(exint idx, fpreal &value) const
238  { doGetParmValue(idx, value); }
240  { doGetParmValue(idx, value); }
242  { doGetParmValue(idx, value); }
244  { doGetParmValue(idx, value); }
246  { doGetParmValue(idx, value); }
248  { doGetParmValue(idx, value); }
250  { doGetParmValue(idx, value); }
252  { doGetParmValue(idx, value); }
254  { doGetParmValue(idx, value); }
256  { doGetParmValue(idx, value); }
257 
258  template <typename T>
259  void
260  doSetParmValue(exint idx, const T &value)
261  {
262  switch (idx)
263  {
264  case 0:
265  coerceValue(myMethod, value);
266  break;
267  case 1:
268  coerceValue(myPointGroup, value);
269  break;
270  case 2:
271  coerceValue(myPrimitiveGroup, value);
272  break;
273  case 3:
274  coerceValue(myAttribute, value);
275  break;
276  case 4:
277  coerceValue(myCurveDir, value);
278  break;
279  case 5:
280  coerceValue(myParentAttribute, value);
281  break;
282  case 6:
283  coerceValue(myRootType, value);
284  break;
285  case 7:
286  coerceValue(myRootGroup, value);
287  break;
288  case 8:
289  coerceValue(myOperation, value);
290  break;
291  case 9:
292  coerceValue(myRootValue, value);
293  break;
294  case 10:
295  coerceValue(myIgnoreAttribute, value);
296  break;
297  case 11:
298  coerceValue(myScaleByEdge, value);
299  break;
300  case 12:
301  coerceValue(mySplitMethod, value);
302  break;
303  case 13:
304  coerceValue(myMergeMethod, value);
305  break;
306 
307  }
308  }
309 
310  void setParmValue(exint idx, const exint &value)
311  { doSetParmValue(idx, value); }
312  void setParmValue(exint idx, const fpreal &value)
313  { doSetParmValue(idx, value); }
314  void setParmValue(exint idx, const UT_Vector2D &value)
315  { doSetParmValue(idx, value); }
316  void setParmValue(exint idx, const UT_Vector3D &value)
317  { doSetParmValue(idx, value); }
318  void setParmValue(exint idx, const UT_Vector4D &value)
319  { doSetParmValue(idx, value); }
320  void setParmValue(exint idx, const UT_Matrix2D &value)
321  { doSetParmValue(idx, value); }
322  void setParmValue(exint idx, const UT_Matrix3D &value)
323  { doSetParmValue(idx, value); }
324  void setParmValue(exint idx, const UT_Matrix4D &value)
325  { doSetParmValue(idx, value); }
327  { doSetParmValue(idx, value); }
329  { doSetParmValue(idx, value); }
331  { doSetParmValue(idx, value); }
332 
333  virtual exint getNumParms() const
334  {
335  return 14;
336  }
337 
338  virtual const char *getParmName(exint fieldnum) const
339  {
340  switch (fieldnum)
341  {
342  case 0:
343  return "method";
344  case 1:
345  return "ptgroup";
346  case 2:
347  return "primgroup";
348  case 3:
349  return "attribute";
350  case 4:
351  return "curvedir";
352  case 5:
353  return "parentattribute";
354  case 6:
355  return "roottype";
356  case 7:
357  return "rootgroup";
358  case 8:
359  return "operation";
360  case 9:
361  return "rootvalue";
362  case 10:
363  return "ignoreattribute";
364  case 11:
365  return "scalebyedge";
366  case 12:
367  return "splitmethod";
368  case 13:
369  return "mergemethod";
370 
371  }
372  return 0;
373  }
374 
375  virtual ParmType getParmType(exint fieldnum) const
376  {
377  switch (fieldnum)
378  {
379  case 0:
380  return PARM_INTEGER;
381  case 1:
382  return PARM_STRING;
383  case 2:
384  return PARM_STRING;
385  case 3:
386  return PARM_STRING;
387  case 4:
388  return PARM_INTEGER;
389  case 5:
390  return PARM_STRING;
391  case 6:
392  return PARM_INTEGER;
393  case 7:
394  return PARM_STRING;
395  case 8:
396  return PARM_INTEGER;
397  case 9:
398  return PARM_INTEGER;
399  case 10:
400  return PARM_INTEGER;
401  case 11:
402  return PARM_INTEGER;
403  case 12:
404  return PARM_INTEGER;
405  case 13:
406  return PARM_INTEGER;
407 
408  }
409  return PARM_UNSUPPORTED;
410  }
411 
412  // Boiler plate to load individual types.
413  static void loadData(UT_IStream &is, int64 &v)
414  { is.bread(&v, 1); }
415  static void loadData(UT_IStream &is, bool &v)
416  { int64 iv; is.bread(&iv, 1); v = iv; }
417  static void loadData(UT_IStream &is, fpreal64 &v)
418  { is.bread<fpreal64>(&v, 1); }
419  static void loadData(UT_IStream &is, UT_Vector2D &v)
420  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
421  static void loadData(UT_IStream &is, UT_Vector3D &v)
422  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
423  is.bread<fpreal64>(&v.z(), 1); }
424  static void loadData(UT_IStream &is, UT_Vector4D &v)
425  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
426  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
427  static void loadData(UT_IStream &is, UT_Matrix2D &v)
428  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
429  static void loadData(UT_IStream &is, UT_Matrix3D &v)
430  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
431  static void loadData(UT_IStream &is, UT_Matrix4D &v)
432  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
433  static void loadData(UT_IStream &is, UT_Vector2I &v)
434  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
435  static void loadData(UT_IStream &is, UT_Vector3I &v)
436  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
437  is.bread<int64>(&v.z(), 1); }
438  static void loadData(UT_IStream &is, UT_Vector4I &v)
439  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
440  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
442  { is.bread(v); }
444  { UT_StringHolder rampdata;
445  loadData(is, rampdata);
446  if (rampdata.isstring())
447  {
448  v.reset(new UT_Ramp());
449  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
450  v->load(istr);
451  }
452  else v.reset();
453  }
456  loadData(is, data);
457  if (data.isstring())
458  {
459  // Find the data type.
460  char *colon = UT_StringWrap(data).findChar(':');
461  if (colon)
462  {
463  int typelen = colon - data.buffer();
465  type.strncpy(data.buffer(), typelen);
466  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
467 
468  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
469  }
470  }
471  else v.reset();
472  }
473 
474  static void saveData(std::ostream &os, int64 v)
475  { UTwrite(os, &v); }
476  static void saveData(std::ostream &os, bool v)
477  { int64 iv = v; UTwrite(os, &iv); }
478  static void saveData(std::ostream &os, fpreal64 v)
479  { UTwrite<fpreal64>(os, &v); }
480  static void saveData(std::ostream &os, UT_Vector2D v)
481  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
482  static void saveData(std::ostream &os, UT_Vector3D v)
483  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
484  UTwrite<fpreal64>(os, &v.z()); }
485  static void saveData(std::ostream &os, UT_Vector4D v)
486  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
487  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
488  static void saveData(std::ostream &os, UT_Matrix2D v)
490  static void saveData(std::ostream &os, UT_Matrix3D v)
492  static void saveData(std::ostream &os, UT_Matrix4D v)
494  static void saveData(std::ostream &os, UT_StringHolder s)
495  { UT_StringWrap(s).saveBinary(os); }
496  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
497  { UT_StringHolder result;
498  UT_OStringStream ostr;
499  if (s) s->save(ostr);
500  result = ostr.str();
501  saveData(os, result);
502  }
503  static void saveData(std::ostream &os, PRM_DataItemHandle s)
504  { UT_StringHolder result;
505  UT_OStringStream ostr;
506  if (s)
507  {
508  ostr << s->getDataTypeToken();
509  ostr << ":";
510  s->saveBinary(ostr);
511  }
512  result = ostr.str();
513  saveData(os, result);
514  }
515 
516 
517  void save(std::ostream &os) const
518  {
519  int32 v = version();
520  UTwrite(os, &v);
521  saveData(os, myMethod);
522  saveData(os, myPointGroup);
523  saveData(os, myPrimitiveGroup);
524  saveData(os, myAttribute);
525  saveData(os, myCurveDir);
526  saveData(os, myParentAttribute);
527  saveData(os, myRootType);
528  saveData(os, myRootGroup);
529  saveData(os, myOperation);
530  saveData(os, myRootValue);
531  saveData(os, myIgnoreAttribute);
532  saveData(os, myScaleByEdge);
533  saveData(os, mySplitMethod);
534  saveData(os, myMergeMethod);
535 
536  }
537 
538  bool load(UT_IStream &is)
539  {
540  int32 v;
541  is.bread(&v, 1);
542  if (version() != v)
543  {
544  // Fail incompatible versions
545  return false;
546  }
547  loadData(is, myMethod);
548  loadData(is, myPointGroup);
549  loadData(is, myPrimitiveGroup);
550  loadData(is, myAttribute);
551  loadData(is, myCurveDir);
552  loadData(is, myParentAttribute);
553  loadData(is, myRootType);
554  loadData(is, myRootGroup);
555  loadData(is, myOperation);
556  loadData(is, myRootValue);
557  loadData(is, myIgnoreAttribute);
558  loadData(is, myScaleByEdge);
559  loadData(is, mySplitMethod);
560  loadData(is, myMergeMethod);
561 
562  return true;
563  }
564 
565  Method getMethod() const { return Method(myMethod); }
566  void setMethod(Method val) { myMethod = int64(val); }
567  Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const
568  {
569  SOP_Node *thissop = cookparms.getNode();
570  if (!thissop) return getMethod();
571  int64 result;
572  OP_Utils::evalOpParm(result, thissop, "method", cookparms.getCookTime(), 0);
573  return Method(result);
574  }
575  const UT_StringHolder & getPointGroup() const { return myPointGroup; }
576  void setPointGroup(const UT_StringHolder & val) { myPointGroup = val; }
578  {
579  SOP_Node *thissop = cookparms.getNode();
580  if (!thissop) return getPointGroup();
581  UT_StringHolder result;
582  OP_Utils::evalOpParm(result, thissop, "ptgroup", cookparms.getCookTime(), 0);
583  return result;
584  }
585  const UT_StringHolder & getPrimitiveGroup() const { return myPrimitiveGroup; }
586  void setPrimitiveGroup(const UT_StringHolder & val) { myPrimitiveGroup = val; }
588  {
589  SOP_Node *thissop = cookparms.getNode();
590  if (!thissop) return getPrimitiveGroup();
591  UT_StringHolder result;
592  OP_Utils::evalOpParm(result, thissop, "primgroup", cookparms.getCookTime(), 0);
593  return result;
594  }
595  const UT_StringHolder & getAttribute() const { return myAttribute; }
596  void setAttribute(const UT_StringHolder & val) { myAttribute = val; }
598  {
599  SOP_Node *thissop = cookparms.getNode();
600  if (!thissop) return getAttribute();
601  UT_StringHolder result;
602  OP_Utils::evalOpParm(result, thissop, "attribute", cookparms.getCookTime(), 0);
603  return result;
604  }
605  CurveDir getCurveDir() const { return CurveDir(myCurveDir); }
606  void setCurveDir(CurveDir val) { myCurveDir = int64(val); }
608  {
609  SOP_Node *thissop = cookparms.getNode();
610  if (!thissop) return getCurveDir();
611  int64 result;
612  OP_Utils::evalOpParm(result, thissop, "curvedir", cookparms.getCookTime(), 0);
613  return CurveDir(result);
614  }
615  const UT_StringHolder & getParentAttribute() const { return myParentAttribute; }
616  void setParentAttribute(const UT_StringHolder & val) { myParentAttribute = val; }
618  {
619  SOP_Node *thissop = cookparms.getNode();
620  if (!thissop) return getParentAttribute();
621  UT_StringHolder result;
622  OP_Utils::evalOpParm(result, thissop, "parentattribute", cookparms.getCookTime(), 0);
623  return result;
624  }
625  RootType getRootType() const { return RootType(myRootType); }
626  void setRootType(RootType val) { myRootType = int64(val); }
628  {
629  SOP_Node *thissop = cookparms.getNode();
630  if (!thissop) return getRootType();
631  int64 result;
632  OP_Utils::evalOpParm(result, thissop, "roottype", cookparms.getCookTime(), 0);
633  return RootType(result);
634  }
635  const UT_StringHolder & getRootGroup() const { return myRootGroup; }
636  void setRootGroup(const UT_StringHolder & val) { myRootGroup = val; }
638  {
639  SOP_Node *thissop = cookparms.getNode();
640  if (!thissop) return getRootGroup();
641  UT_StringHolder result;
642  OP_Utils::evalOpParm(result, thissop, "rootgroup", cookparms.getCookTime(), 0);
643  return result;
644  }
645  Operation getOperation() const { return Operation(myOperation); }
646  void setOperation(Operation val) { myOperation = int64(val); }
648  {
649  SOP_Node *thissop = cookparms.getNode();
650  if (!thissop) return getOperation();
651  int64 result;
652  OP_Utils::evalOpParm(result, thissop, "operation", cookparms.getCookTime(), 0);
653  return Operation(result);
654  }
655  RootValue getRootValue() const { return RootValue(myRootValue); }
656  void setRootValue(RootValue val) { myRootValue = int64(val); }
658  {
659  SOP_Node *thissop = cookparms.getNode();
660  if (!thissop) return getRootValue();
661  int64 result;
662  OP_Utils::evalOpParm(result, thissop, "rootvalue", cookparms.getCookTime(), 0);
663  return RootValue(result);
664  }
665  bool getIgnoreAttribute() const { return myIgnoreAttribute; }
666  void setIgnoreAttribute(bool val) { myIgnoreAttribute = val; }
667  bool opIgnoreAttribute(const SOP_NodeVerb::CookParms &cookparms) const
668  {
669  SOP_Node *thissop = cookparms.getNode();
670  if (!thissop) return getIgnoreAttribute();
671  bool result;
672  OP_Utils::evalOpParm(result, thissop, "ignoreattribute", cookparms.getCookTime(), 0);
673  return result;
674  }
675  bool getScaleByEdge() const { return myScaleByEdge; }
676  void setScaleByEdge(bool val) { myScaleByEdge = val; }
677  bool opScaleByEdge(const SOP_NodeVerb::CookParms &cookparms) const
678  {
679  SOP_Node *thissop = cookparms.getNode();
680  if (!thissop) return getScaleByEdge();
681  bool result;
682  OP_Utils::evalOpParm(result, thissop, "scalebyedge", cookparms.getCookTime(), 0);
683  return result;
684  }
685  SplitMethod getSplitMethod() const { return SplitMethod(mySplitMethod); }
686  void setSplitMethod(SplitMethod val) { mySplitMethod = int64(val); }
688  {
689  SOP_Node *thissop = cookparms.getNode();
690  if (!thissop) return getSplitMethod();
691  int64 result;
692  OP_Utils::evalOpParm(result, thissop, "splitmethod", cookparms.getCookTime(), 0);
693  return SplitMethod(result);
694  }
695  MergeMethod getMergeMethod() const { return MergeMethod(myMergeMethod); }
696  void setMergeMethod(MergeMethod val) { myMergeMethod = int64(val); }
698  {
699  SOP_Node *thissop = cookparms.getNode();
700  if (!thissop) return getMergeMethod();
701  int64 result;
702  OP_Utils::evalOpParm(result, thissop, "mergemethod", cookparms.getCookTime(), 0);
703  return MergeMethod(result);
704  }
705 
706 private:
707  int64 myMethod;
708  UT_StringHolder myPointGroup;
709  UT_StringHolder myPrimitiveGroup;
710  UT_StringHolder myAttribute;
711  int64 myCurveDir;
712  UT_StringHolder myParentAttribute;
713  int64 myRootType;
714  UT_StringHolder myRootGroup;
715  int64 myOperation;
716  int64 myRootValue;
717  bool myIgnoreAttribute;
718  bool myScaleByEdge;
719  int64 mySplitMethod;
720  int64 myMergeMethod;
721 
722 };
void save(std::ostream &os) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
void setPointGroup(const UT_StringHolder &val)
void getParmValue(exint idx, UT_Vector4D &value) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
void setParmValue(exint idx, const UT_StringHolder &value)
void setParentAttribute(const UT_StringHolder &val)
T & z(void)
Definition: UT_Vector4.h:372
const UT_StringHolder & getPrimitiveGroup() const
static void saveData(std::ostream &os, UT_StringHolder s)
static void loadData(UT_IStream &is, UT_Vector4D &v)
bool opScaleByEdge(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, fpreal64 v)
void getParmValue(exint idx, exint &value) const
exint bread(int32 *buffer, exint asize=1)
RootType opRootType(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:34
const GLdouble * v
Definition: glcorearb.h:836
void setParmValue(exint idx, const UT_Matrix3D &value)
void setOperation(Operation val)
void doGetParmValue(exint idx, T &value) const
static void loadData(UT_IStream &is, bool &v)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
UT_StringHolder opRootGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3I &v)
virtual ParmType getParmType(exint fieldnum) const
static void saveData(std::ostream &os, UT_Vector2D v)
const UT_StringHolder & getAttribute() const
T & x(void)
Definition: UT_Vector2.h:284
An output stream object that owns its own string buffer storage.
void setParmValue(exint idx, const UT_Matrix4D &value)
const UT_StringHolder & getPointGroup() const
virtual exint getNumParms() const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void getParmValue(exint idx, UT_StringHolder &value) const
UT_StringHolder opAttribute(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
static void saveData(std::ostream &os, UT_Vector3D v)
SplitMethod opSplitMethod(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
bool operator==(const SOP_EdgeTransportParms &src) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
void setParmValue(exint idx, const exint &value)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void getParmValue(exint idx, UT_Matrix3D &value) const
void setParmValue(exint idx, const fpreal &value)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
static void saveData(std::ostream &os, UT_Matrix2D v)
long long int64
Definition: SYS_Types.h:106
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
SYS_FORCE_INLINE const char * buffer() const
int64 exint
Definition: SYS_Types.h:115
static void loadData(UT_IStream &is, fpreal64 &v)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:191
static void saveData(std::ostream &os, bool v)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
void setParmValue(exint idx, const UT_Vector4D &value)
SplitMethod getSplitMethod() const
virtual void loadFromOpSubclass(const LoadParms &loadparms)
static void saveData(std::ostream &os, int64 v)
static void saveData(std::ostream &os, UT_Matrix4D v)
Operation opOperation(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector2D &value) const
GLboolean * data
Definition: glcorearb.h:130
int int32
Definition: SYS_Types.h:34
const UT_StringHolder & getRootGroup() const
T & y(void)
Definition: UT_Vector4.h:370
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
MergeMethod opMergeMethod(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
static void loadData(UT_IStream &is, UT_Matrix3D &v)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
void getParmValue(exint idx, UT_Matrix4D &value) const
void setSplitMethod(SplitMethod val)
void setRootValue(RootValue val)
static void loadData(UT_IStream &is, int64 &v)
static void loadData(UT_IStream &is, UT_StringHolder &v)
static void loadData(UT_IStream &is, UT_Vector4I &v)
void getParmValue(exint idx, UT_Matrix2D &value) 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, PRM_DataItemHandle &v)
void strncpy(const char *src, exint maxlen)
void setRootGroup(const UT_StringHolder &val)
void setPrimitiveGroup(const UT_StringHolder &val)
void setParmValue(exint idx, const UT_Vector2D &value)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
RootValue opRootValue(const SOP_NodeVerb::CookParms &cookparms) const
void setMergeMethod(MergeMethod val)
void doSetParmValue(exint idx, const T &value)
GLuint GLfloat * val
Definition: glcorearb.h:1607
const UT_StringHolder & getParentAttribute() const
#define SOP_API
Definition: SOP_API.h:10
void setParmValue(exint idx, const UT_Matrix2D &value)
void getParmValue(exint idx, fpreal &value) const
static void loadData(UT_IStream &is, UT_Vector3D &v)
const char * buffer() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
void setAttribute(const UT_StringHolder &val)
T & x(void)
Definition: UT_Vector4.h:368
virtual const char * getParmName(exint fieldnum) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
T & y(void)
Definition: UT_Vector2.h:286
GLboolean r
Definition: glcorearb.h:1221
bool opIgnoreAttribute(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector3D &value) const
T & w(void)
Definition: UT_Vector4.h:374
static void saveData(std::ostream &os, UT_Matrix3D v)
virtual void copyFrom(const SOP_NodeParms *src)
static void saveData(std::ostream &os, UT_Vector4D v)
UT_StringHolder opPrimitiveGroup(const SOP_NodeVerb::CookParms &cookparms) const
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
CurveDir opCurveDir(const SOP_NodeVerb::CookParms &cookparms) const
MergeMethod getMergeMethod() const
UT_StringHolder opPointGroup(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE bool isstring() const
void setParmValue(exint idx, const UT_Vector3D &value)
UT_StringHolder opParentAttribute(const SOP_NodeVerb::CookParms &cookparms) const
GLenum src
Definition: glcorearb.h:1792
static void loadData(UT_IStream &is, UT_Matrix4D &v)
Method opMethod(const SOP_NodeVerb::CookParms &cookparms) const