HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_Facet.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_FacetEnums
22 {
23  enum class Cons
24  {
25  NONE = 0,
26  POINTS,
27  FPOINTS,
28  NORMALS,
29  FNORMALS
30  };
31 }
32 
33 
35 {
36 public:
37  static int version() { return 1; }
38 
40  {
41  myGroup = ""_sh;
42  myPrenml = false;
43  myUnit = false;
44  myUnique = false;
45  myCons = 0;
46  myDist = 0.001;
47  myAccurate = true;
48  myInline = false;
49  myInlinedist = 0.001;
50  myOrientpolys = false;
51  myCusp = false;
52  myAngle = 20;
53  myRemove = false;
54  myMkplanar = false;
55  myPostnml = false;
56  myReversenml = false;
57 
58  }
59 
60  explicit SOP_FacetParms(const SOP_FacetParms &) = default;
61 
62  virtual ~SOP_FacetParms() {}
63 
64  bool operator==(const SOP_FacetParms &src) const
65  {
66  if (myGroup != src.myGroup) return false;
67  if (myPrenml != src.myPrenml) return false;
68  if (myUnit != src.myUnit) return false;
69  if (myUnique != src.myUnique) return false;
70  if (myCons != src.myCons) return false;
71  if (myDist != src.myDist) return false;
72  if (myAccurate != src.myAccurate) return false;
73  if (myInline != src.myInline) return false;
74  if (myInlinedist != src.myInlinedist) return false;
75  if (myOrientpolys != src.myOrientpolys) return false;
76  if (myCusp != src.myCusp) return false;
77  if (myAngle != src.myAngle) return false;
78  if (myRemove != src.myRemove) return false;
79  if (myMkplanar != src.myMkplanar) return false;
80  if (myPostnml != src.myPostnml) return false;
81  if (myReversenml != src.myReversenml) return false;
82 
83  return true;
84  }
86 
87 
88 
89  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
90  {
91  if (true)
92  OP_Utils::evalOpParm(myGroup, node, "group", time, 0);
93  else myGroup = ""_sh;
94  if (true)
95  OP_Utils::evalOpParm(myPrenml, node, "prenml", time, 0);
96  else myPrenml = false;
97  if (true && ( (!(((getPrenml()==1)))) ) )
98  OP_Utils::evalOpParm(myUnit, node, "unit", time, 0);
99  else myUnit = false;
100  if (true)
101  OP_Utils::evalOpParm(myUnique, node, "unique", time, 0);
102  else myUnique = false;
103  if (true)
104  OP_Utils::evalOpParm(myCons, node, "cons", time, 0);
105  else myCons = 0;
106  if (true && ( (!(((int64(getCons())==0)))) ) )
107  OP_Utils::evalOpParm(myDist, node, "dist", time, 0);
108  else myDist = 0.001;
109  if (true && ( (!(((int64(getCons())==0)))) ) )
110  OP_Utils::evalOpParm(myAccurate, node, "accurate", time, 0);
111  else myAccurate = true;
112  if (true)
113  OP_Utils::evalOpParm(myInline, node, "inline", time, 0);
114  else myInline = false;
115  if (true && ( (!(((getInline()==0)))) ) )
116  OP_Utils::evalOpParm(myInlinedist, node, "inlinedist", time, 0);
117  else myInlinedist = 0.001;
118  if (true)
119  OP_Utils::evalOpParm(myOrientpolys, node, "orientPolys", time, 0);
120  else myOrientpolys = false;
121  if (true)
122  OP_Utils::evalOpParm(myCusp, node, "cusp", time, 0);
123  else myCusp = false;
124  if (true && ( (!(((getCusp()==0)))) ) )
125  OP_Utils::evalOpParm(myAngle, node, "angle", time, 0);
126  else myAngle = 20;
127  if (true)
128  OP_Utils::evalOpParm(myRemove, node, "remove", time, 0);
129  else myRemove = false;
130  if (true)
131  OP_Utils::evalOpParm(myMkplanar, node, "mkplanar", time, 0);
132  else myMkplanar = false;
133  if (true)
134  OP_Utils::evalOpParm(myPostnml, node, "postnml", time, 0);
135  else myPostnml = false;
136  if (true)
137  OP_Utils::evalOpParm(myReversenml, node, "reversenml", time, 0);
138  else myReversenml = false;
139 
140  }
141 
142 
143  virtual void loadFromOpSubclass(const LoadParms &loadparms)
144  {
145  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
146  }
147 
148 
149  virtual void copyFrom(const SOP_NodeParms *src)
150  {
151  *this = *((const SOP_FacetParms *)src);
152  }
153 
154  template <typename T>
155  void
156  doGetParmValue(exint idx, T &value) const
157  {
158  switch (idx)
159  {
160  case 0:
161  coerceValue(value, myGroup);
162  break;
163  case 1:
164  coerceValue(value, myPrenml);
165  break;
166  case 2:
167  coerceValue(value, myUnit);
168  break;
169  case 3:
170  coerceValue(value, myUnique);
171  break;
172  case 4:
173  coerceValue(value, myCons);
174  break;
175  case 5:
176  coerceValue(value, myDist);
177  break;
178  case 6:
179  coerceValue(value, myAccurate);
180  break;
181  case 7:
182  coerceValue(value, myInline);
183  break;
184  case 8:
185  coerceValue(value, myInlinedist);
186  break;
187  case 9:
188  coerceValue(value, myOrientpolys);
189  break;
190  case 10:
191  coerceValue(value, myCusp);
192  break;
193  case 11:
194  coerceValue(value, myAngle);
195  break;
196  case 12:
197  coerceValue(value, myRemove);
198  break;
199  case 13:
200  coerceValue(value, myMkplanar);
201  break;
202  case 14:
203  coerceValue(value, myPostnml);
204  break;
205  case 15:
206  coerceValue(value, myReversenml);
207  break;
208 
209  }
210  }
211 
212  void getParmValue(exint idx, exint &value) const
213  { doGetParmValue(idx, value); }
214  void getParmValue(exint idx, fpreal &value) const
215  { doGetParmValue(idx, value); }
217  { doGetParmValue(idx, value); }
219  { doGetParmValue(idx, value); }
221  { doGetParmValue(idx, value); }
223  { doGetParmValue(idx, value); }
225  { doGetParmValue(idx, value); }
227  { doGetParmValue(idx, value); }
229  { doGetParmValue(idx, value); }
231  { doGetParmValue(idx, value); }
233  { doGetParmValue(idx, value); }
234 
235  template <typename T>
236  void
237  doSetParmValue(exint idx, const T &value)
238  {
239  switch (idx)
240  {
241  case 0:
242  coerceValue(myGroup, value);
243  break;
244  case 1:
245  coerceValue(myPrenml, value);
246  break;
247  case 2:
248  coerceValue(myUnit, value);
249  break;
250  case 3:
251  coerceValue(myUnique, value);
252  break;
253  case 4:
254  coerceValue(myCons, value);
255  break;
256  case 5:
257  coerceValue(myDist, value);
258  break;
259  case 6:
260  coerceValue(myAccurate, value);
261  break;
262  case 7:
263  coerceValue(myInline, value);
264  break;
265  case 8:
266  coerceValue(myInlinedist, value);
267  break;
268  case 9:
269  coerceValue(myOrientpolys, value);
270  break;
271  case 10:
272  coerceValue(myCusp, value);
273  break;
274  case 11:
275  coerceValue(myAngle, value);
276  break;
277  case 12:
278  coerceValue(myRemove, value);
279  break;
280  case 13:
281  coerceValue(myMkplanar, value);
282  break;
283  case 14:
284  coerceValue(myPostnml, value);
285  break;
286  case 15:
287  coerceValue(myReversenml, value);
288  break;
289 
290  }
291  }
292 
293  void setParmValue(exint idx, const exint &value)
294  { doSetParmValue(idx, value); }
295  void setParmValue(exint idx, const fpreal &value)
296  { doSetParmValue(idx, value); }
297  void setParmValue(exint idx, const UT_Vector2D &value)
298  { doSetParmValue(idx, value); }
299  void setParmValue(exint idx, const UT_Vector3D &value)
300  { doSetParmValue(idx, value); }
301  void setParmValue(exint idx, const UT_Vector4D &value)
302  { doSetParmValue(idx, value); }
303  void setParmValue(exint idx, const UT_Matrix2D &value)
304  { doSetParmValue(idx, value); }
305  void setParmValue(exint idx, const UT_Matrix3D &value)
306  { doSetParmValue(idx, value); }
307  void setParmValue(exint idx, const UT_Matrix4D &value)
308  { doSetParmValue(idx, value); }
310  { doSetParmValue(idx, value); }
312  { doSetParmValue(idx, value); }
314  { doSetParmValue(idx, value); }
315 
316  virtual exint getNumParms() const
317  {
318  return 16;
319  }
320 
321  virtual const char *getParmName(exint fieldnum) const
322  {
323  switch (fieldnum)
324  {
325  case 0:
326  return "group";
327  case 1:
328  return "prenml";
329  case 2:
330  return "unit";
331  case 3:
332  return "unique";
333  case 4:
334  return "cons";
335  case 5:
336  return "dist";
337  case 6:
338  return "accurate";
339  case 7:
340  return "inline";
341  case 8:
342  return "inlinedist";
343  case 9:
344  return "orientPolys";
345  case 10:
346  return "cusp";
347  case 11:
348  return "angle";
349  case 12:
350  return "remove";
351  case 13:
352  return "mkplanar";
353  case 14:
354  return "postnml";
355  case 15:
356  return "reversenml";
357 
358  }
359  return 0;
360  }
361 
362  virtual ParmType getParmType(exint fieldnum) const
363  {
364  switch (fieldnum)
365  {
366  case 0:
367  return PARM_STRING;
368  case 1:
369  return PARM_INTEGER;
370  case 2:
371  return PARM_INTEGER;
372  case 3:
373  return PARM_INTEGER;
374  case 4:
375  return PARM_INTEGER;
376  case 5:
377  return PARM_FLOAT;
378  case 6:
379  return PARM_INTEGER;
380  case 7:
381  return PARM_INTEGER;
382  case 8:
383  return PARM_FLOAT;
384  case 9:
385  return PARM_INTEGER;
386  case 10:
387  return PARM_INTEGER;
388  case 11:
389  return PARM_FLOAT;
390  case 12:
391  return PARM_INTEGER;
392  case 13:
393  return PARM_INTEGER;
394  case 14:
395  return PARM_INTEGER;
396  case 15:
397  return PARM_INTEGER;
398 
399  }
400  return PARM_UNSUPPORTED;
401  }
402 
403  // Boiler plate to load individual types.
404  static void loadData(UT_IStream &is, int64 &v)
405  { is.bread(&v, 1); }
406  static void loadData(UT_IStream &is, bool &v)
407  { int64 iv; is.bread(&iv, 1); v = iv; }
408  static void loadData(UT_IStream &is, fpreal64 &v)
409  { is.bread<fpreal64>(&v, 1); }
410  static void loadData(UT_IStream &is, UT_Vector2D &v)
411  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
412  static void loadData(UT_IStream &is, UT_Vector3D &v)
413  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
414  is.bread<fpreal64>(&v.z(), 1); }
415  static void loadData(UT_IStream &is, UT_Vector4D &v)
416  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
417  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
418  static void loadData(UT_IStream &is, UT_Matrix2D &v)
419  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
420  static void loadData(UT_IStream &is, UT_Matrix3D &v)
421  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
422  static void loadData(UT_IStream &is, UT_Matrix4D &v)
423  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
424  static void loadData(UT_IStream &is, UT_Vector2I &v)
425  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
426  static void loadData(UT_IStream &is, UT_Vector3I &v)
427  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
428  is.bread<int64>(&v.z(), 1); }
429  static void loadData(UT_IStream &is, UT_Vector4I &v)
430  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
431  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
433  { is.bread(v); }
435  { UT_StringHolder rampdata;
436  loadData(is, rampdata);
437  if (rampdata.isstring())
438  {
439  v.reset(new UT_Ramp());
440  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
441  v->load(istr);
442  }
443  else v.reset();
444  }
447  loadData(is, data);
448  if (data.isstring())
449  {
450  // Find the data type.
451  char *colon = UT_StringWrap(data).findChar(':');
452  if (colon)
453  {
454  int typelen = colon - data.buffer();
456  type.strncpy(data.buffer(), typelen);
457  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
458 
459  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
460  }
461  }
462  else v.reset();
463  }
464 
465  static void saveData(std::ostream &os, int64 v)
466  { UTwrite(os, &v); }
467  static void saveData(std::ostream &os, bool v)
468  { int64 iv = v; UTwrite(os, &iv); }
469  static void saveData(std::ostream &os, fpreal64 v)
470  { UTwrite<fpreal64>(os, &v); }
471  static void saveData(std::ostream &os, UT_Vector2D v)
472  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
473  static void saveData(std::ostream &os, UT_Vector3D v)
474  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
475  UTwrite<fpreal64>(os, &v.z()); }
476  static void saveData(std::ostream &os, UT_Vector4D v)
477  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
478  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
479  static void saveData(std::ostream &os, UT_Matrix2D v)
481  static void saveData(std::ostream &os, UT_Matrix3D v)
483  static void saveData(std::ostream &os, UT_Matrix4D v)
485  static void saveData(std::ostream &os, UT_StringHolder s)
486  { UT_StringWrap(s).saveBinary(os); }
487  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
488  { UT_StringHolder result;
489  UT_OStringStream ostr;
490  if (s) s->save(ostr);
491  result = ostr.str();
492  saveData(os, result);
493  }
494  static void saveData(std::ostream &os, PRM_DataItemHandle s)
495  { UT_StringHolder result;
496  UT_OStringStream ostr;
497  if (s)
498  {
499  ostr << s->getDataTypeToken();
500  ostr << ":";
501  s->saveBinary(ostr);
502  }
503  result = ostr.str();
504  saveData(os, result);
505  }
506 
507 
508  void save(std::ostream &os) const
509  {
510  int32 v = version();
511  UTwrite(os, &v);
512  saveData(os, myGroup);
513  saveData(os, myPrenml);
514  saveData(os, myUnit);
515  saveData(os, myUnique);
516  saveData(os, myCons);
517  saveData(os, myDist);
518  saveData(os, myAccurate);
519  saveData(os, myInline);
520  saveData(os, myInlinedist);
521  saveData(os, myOrientpolys);
522  saveData(os, myCusp);
523  saveData(os, myAngle);
524  saveData(os, myRemove);
525  saveData(os, myMkplanar);
526  saveData(os, myPostnml);
527  saveData(os, myReversenml);
528 
529  }
530 
531  bool load(UT_IStream &is)
532  {
533  int32 v;
534  is.bread(&v, 1);
535  if (version() != v)
536  {
537  // Fail incompatible versions
538  return false;
539  }
540  loadData(is, myGroup);
541  loadData(is, myPrenml);
542  loadData(is, myUnit);
543  loadData(is, myUnique);
544  loadData(is, myCons);
545  loadData(is, myDist);
546  loadData(is, myAccurate);
547  loadData(is, myInline);
548  loadData(is, myInlinedist);
549  loadData(is, myOrientpolys);
550  loadData(is, myCusp);
551  loadData(is, myAngle);
552  loadData(is, myRemove);
553  loadData(is, myMkplanar);
554  loadData(is, myPostnml);
555  loadData(is, myReversenml);
556 
557  return true;
558  }
559 
560  const UT_StringHolder & getGroup() const { return myGroup; }
561  void setGroup(const UT_StringHolder & val) { myGroup = val; }
563  {
564  SOP_Node *thissop = cookparms.getNode();
565  if (!thissop) return getGroup();
566  UT_StringHolder result;
567  OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
568  return result;
569  }
570  bool getPrenml() const { return myPrenml; }
571  void setPrenml(bool val) { myPrenml = val; }
572  bool opPrenml(const SOP_NodeVerb::CookParms &cookparms) const
573  {
574  SOP_Node *thissop = cookparms.getNode();
575  if (!thissop) return getPrenml();
576  bool result;
577  OP_Utils::evalOpParm(result, thissop, "prenml", cookparms.getCookTime(), 0);
578  return result;
579  }
580  bool getUnit() const { return myUnit; }
581  void setUnit(bool val) { myUnit = val; }
582  bool opUnit(const SOP_NodeVerb::CookParms &cookparms) const
583  {
584  SOP_Node *thissop = cookparms.getNode();
585  if (!thissop) return getUnit();
586  bool result;
587  OP_Utils::evalOpParm(result, thissop, "unit", cookparms.getCookTime(), 0);
588  return result;
589  }
590  bool getUnique() const { return myUnique; }
591  void setUnique(bool val) { myUnique = val; }
592  bool opUnique(const SOP_NodeVerb::CookParms &cookparms) const
593  {
594  SOP_Node *thissop = cookparms.getNode();
595  if (!thissop) return getUnique();
596  bool result;
597  OP_Utils::evalOpParm(result, thissop, "unique", cookparms.getCookTime(), 0);
598  return result;
599  }
600  Cons getCons() const { return Cons(myCons); }
601  void setCons(Cons val) { myCons = int64(val); }
602  Cons opCons(const SOP_NodeVerb::CookParms &cookparms) const
603  {
604  SOP_Node *thissop = cookparms.getNode();
605  if (!thissop) return getCons();
606  int64 result;
607  OP_Utils::evalOpParm(result, thissop, "cons", cookparms.getCookTime(), 0);
608  return Cons(result);
609  }
610  fpreal64 getDist() const { return myDist; }
611  void setDist(fpreal64 val) { myDist = val; }
612  fpreal64 opDist(const SOP_NodeVerb::CookParms &cookparms) const
613  {
614  SOP_Node *thissop = cookparms.getNode();
615  if (!thissop) return getDist();
616  fpreal64 result;
617  OP_Utils::evalOpParm(result, thissop, "dist", cookparms.getCookTime(), 0);
618  return result;
619  }
620  bool getAccurate() const { return myAccurate; }
621  void setAccurate(bool val) { myAccurate = val; }
622  bool opAccurate(const SOP_NodeVerb::CookParms &cookparms) const
623  {
624  SOP_Node *thissop = cookparms.getNode();
625  if (!thissop) return getAccurate();
626  bool result;
627  OP_Utils::evalOpParm(result, thissop, "accurate", cookparms.getCookTime(), 0);
628  return result;
629  }
630  bool getInline() const { return myInline; }
631  void setInline(bool val) { myInline = val; }
632  bool opInline(const SOP_NodeVerb::CookParms &cookparms) const
633  {
634  SOP_Node *thissop = cookparms.getNode();
635  if (!thissop) return getInline();
636  bool result;
637  OP_Utils::evalOpParm(result, thissop, "inline", cookparms.getCookTime(), 0);
638  return result;
639  }
640  fpreal64 getInlinedist() const { return myInlinedist; }
641  void setInlinedist(fpreal64 val) { myInlinedist = val; }
643  {
644  SOP_Node *thissop = cookparms.getNode();
645  if (!thissop) return getInlinedist();
646  fpreal64 result;
647  OP_Utils::evalOpParm(result, thissop, "inlinedist", cookparms.getCookTime(), 0);
648  return result;
649  }
650  bool getOrientpolys() const { return myOrientpolys; }
651  void setOrientpolys(bool val) { myOrientpolys = val; }
652  bool opOrientpolys(const SOP_NodeVerb::CookParms &cookparms) const
653  {
654  SOP_Node *thissop = cookparms.getNode();
655  if (!thissop) return getOrientpolys();
656  bool result;
657  OP_Utils::evalOpParm(result, thissop, "orientPolys", cookparms.getCookTime(), 0);
658  return result;
659  }
660  bool getCusp() const { return myCusp; }
661  void setCusp(bool val) { myCusp = val; }
662  bool opCusp(const SOP_NodeVerb::CookParms &cookparms) const
663  {
664  SOP_Node *thissop = cookparms.getNode();
665  if (!thissop) return getCusp();
666  bool result;
667  OP_Utils::evalOpParm(result, thissop, "cusp", cookparms.getCookTime(), 0);
668  return result;
669  }
670  fpreal64 getAngle() const { return myAngle; }
671  void setAngle(fpreal64 val) { myAngle = val; }
672  fpreal64 opAngle(const SOP_NodeVerb::CookParms &cookparms) const
673  {
674  SOP_Node *thissop = cookparms.getNode();
675  if (!thissop) return getAngle();
676  fpreal64 result;
677  OP_Utils::evalOpParm(result, thissop, "angle", cookparms.getCookTime(), 0);
678  return result;
679  }
680  bool getRemove() const { return myRemove; }
681  void setRemove(bool val) { myRemove = val; }
682  bool opRemove(const SOP_NodeVerb::CookParms &cookparms) const
683  {
684  SOP_Node *thissop = cookparms.getNode();
685  if (!thissop) return getRemove();
686  bool result;
687  OP_Utils::evalOpParm(result, thissop, "remove", cookparms.getCookTime(), 0);
688  return result;
689  }
690  bool getMkplanar() const { return myMkplanar; }
691  void setMkplanar(bool val) { myMkplanar = val; }
692  bool opMkplanar(const SOP_NodeVerb::CookParms &cookparms) const
693  {
694  SOP_Node *thissop = cookparms.getNode();
695  if (!thissop) return getMkplanar();
696  bool result;
697  OP_Utils::evalOpParm(result, thissop, "mkplanar", cookparms.getCookTime(), 0);
698  return result;
699  }
700  bool getPostnml() const { return myPostnml; }
701  void setPostnml(bool val) { myPostnml = val; }
702  bool opPostnml(const SOP_NodeVerb::CookParms &cookparms) const
703  {
704  SOP_Node *thissop = cookparms.getNode();
705  if (!thissop) return getPostnml();
706  bool result;
707  OP_Utils::evalOpParm(result, thissop, "postnml", cookparms.getCookTime(), 0);
708  return result;
709  }
710  bool getReversenml() const { return myReversenml; }
711  void setReversenml(bool val) { myReversenml = val; }
712  bool opReversenml(const SOP_NodeVerb::CookParms &cookparms) const
713  {
714  SOP_Node *thissop = cookparms.getNode();
715  if (!thissop) return getReversenml();
716  bool result;
717  OP_Utils::evalOpParm(result, thissop, "reversenml", cookparms.getCookTime(), 0);
718  return result;
719  }
720 
721 private:
722  UT_StringHolder myGroup;
723  bool myPrenml;
724  bool myUnit;
725  bool myUnique;
726  int64 myCons;
727  fpreal64 myDist;
728  bool myAccurate;
729  bool myInline;
730  fpreal64 myInlinedist;
731  bool myOrientpolys;
732  bool myCusp;
733  fpreal64 myAngle;
734  bool myRemove;
735  bool myMkplanar;
736  bool myPostnml;
737  bool myReversenml;
738 
739 };
void save(std::ostream &os) const
void setParmValue(exint idx, const exint &value)
bool opAccurate(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, int64 &v)
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
void getParmValue(exint idx, UT_Matrix4D &value) const
void setRemove(bool val)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
void doSetParmValue(exint idx, const T &value)
T & z(void)
Definition: UT_Vector4.h:372
bool opReversenml(const SOP_NodeVerb::CookParms &cookparms) const
bool getCusp() const
bool getRemove() const
void setParmValue(exint idx, const UT_StringHolder &value)
static void saveData(std::ostream &os, int64 v)
void setInline(bool val)
exint bread(int32 *buffer, exint asize=1)
void setParmValue(exint idx, const UT_Vector4D &value)
fpreal getTime() const
Definition: OP_Context.h:34
const GLdouble * v
Definition: glcorearb.h:836
bool getMkplanar() const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void setInlinedist(fpreal64 val)
static void saveData(std::ostream &os, UT_StringHolder s)
void setMkplanar(bool val)
void getParmValue(exint idx, UT_Vector3D &value) const
bool opUnique(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3I &v)
bool load(UT_IStream &is)
T & x(void)
Definition: UT_Vector2.h:284
void setUnit(bool val)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
An output stream object that owns its own string buffer storage.
static void loadData(UT_IStream &is, fpreal64 &v)
static void loadData(UT_IStream &is, UT_Vector3D &v)
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setCusp(bool val)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
virtual const char * getParmName(exint fieldnum) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
bool getReversenml() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
virtual void copyFrom(const SOP_NodeParms *src)
bool opUnit(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Vector2D &value)
static void loadData(UT_IStream &is, UT_Vector2D &v)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
bool operator==(const SOP_FacetParms &src) const
long long int64
Definition: SYS_Types.h:106
void setParmValue(exint idx, const fpreal &value)
void getParmValue(exint idx, UT_StringHolder &value) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool getUnit() const
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
static void saveData(std::ostream &os, UT_Vector2D v)
void setAngle(fpreal64 val)
SYS_FORCE_INLINE const char * buffer() const
void getParmValue(exint idx, UT_Vector2D &value) const
int64 exint
Definition: SYS_Types.h:115
static void loadData(UT_IStream &is, UT_Matrix4D &v)
virtual ~SOP_FacetParms()
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:191
bool opMkplanar(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
virtual void loadFromOpSubclass(const LoadParms &loadparms)
void setOrientpolys(bool val)
fpreal64 opInlinedist(const SOP_NodeVerb::CookParms &cookparms) const
Cons opCons(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix4D v)
bool opPostnml(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector3D v)
void getParmValue(exint idx, UT_Vector4D &value) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
virtual ParmType getParmType(exint fieldnum) const
static void saveData(std::ostream &os, fpreal64 v)
void getParmValue(exint idx, exint &value) const
void setParmValue(exint idx, const PRM_DataItemHandle &value)
GLboolean * data
Definition: glcorearb.h:130
static int version()
Cons getCons() const
fpreal64 opAngle(const SOP_NodeVerb::CookParms &cookparms) const
int int32
Definition: SYS_Types.h:34
void setDist(fpreal64 val)
T & y(void)
Definition: UT_Vector4.h:370
void setParmValue(exint idx, const UT_Matrix4D &value)
void setGroup(const UT_StringHolder &val)
void setPrenml(bool val)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
static void saveData(std::ostream &os, UT_Matrix3D v)
void setParmValue(exint idx, const UT_Matrix3D &value)
void getParmValue(exint idx, UT_Matrix2D &value) const
void getParmValue(exint idx, PRM_DataItemHandle &value) const
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
virtual exint getNumParms() const
void setPostnml(bool val)
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
fpreal64 getInlinedist() const
double fpreal
Definition: SYS_Types.h:269
void strncpy(const char *src, exint maxlen)
bool getInline() const
fpreal64 opDist(const SOP_NodeVerb::CookParms &cookparms) const
bool opInline(const SOP_NodeVerb::CookParms &cookparms) const
bool getPostnml() const
void setParmValue(exint idx, const UT_Matrix2D &value)
fpreal64 getAngle() const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
static void saveData(std::ostream &os, UT_Vector4D v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
static void loadData(UT_IStream &is, UT_Matrix3D &v)
bool getOrientpolys() const
fpreal64 getDist() const
GLuint GLfloat * val
Definition: glcorearb.h:1607
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
#define SOP_API
Definition: SOP_API.h:10
bool getAccurate() const
bool opOrientpolys(const SOP_NodeVerb::CookParms &cookparms) const
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
T & y(void)
Definition: UT_Vector2.h:286
bool opCusp(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4D &v)
void setCons(Cons val)
static void saveData(std::ostream &os, UT_Matrix2D v)
const UT_StringHolder & getGroup() const
void setUnique(bool val)
GLboolean r
Definition: glcorearb.h:1221
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void setReversenml(bool val)
void setParmValue(exint idx, const UT_Vector3D &value)
void getParmValue(exint idx, UT_Matrix3D &value) const
T & w(void)
Definition: UT_Vector4.h:374
bool opRemove(const SOP_NodeVerb::CookParms &cookparms) const
bool getUnique() const
void getParmValue(exint idx, fpreal &value) const
void setAccurate(bool val)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
SYS_FORCE_INLINE bool isstring() const
static void loadData(UT_IStream &is, bool &v)
bool opPrenml(const SOP_NodeVerb::CookParms &cookparms) const
bool getPrenml() const
void doGetParmValue(exint idx, T &value) const
GLenum src
Definition: glcorearb.h:1792
static void loadData(UT_IStream &is, UT_StringHolder &v)